fix(tests): proper dummy transport clean up for hub cloning (#2957)

* test(test_helper): add failing regression specs for clone_hub event leak (#2951)

Captures the documented bug where setup_sentry_test is ineffective in
request specs because clone_hub_to_current_thread clones @main_hub rather
than the thread-local hub setup_sentry_test mutated, and DummyTransport
has no #clear, so events from a prior unrelated request leak into a later
test via the main hub's base-layer DummyTransport.

- Reproduction spec (intentional TDD red): after a setup/teardown cycle,
  an intermediate clone_hub_to_current_thread + capture, then a second
  setup_sentry_test, sentry_events must be empty both immediately and
  after a further clone_hub_to_current_thread. Currently the second
  assertion fails because the stale event is still visible.
- Guard spec (passes today, must keep passing): events captured through
  a hub cloned by the Rack middleware after setup_sentry_test remain
  observable via sentry_events, so the eventual fix cannot regress by
  silently dropping request-captured events.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* feat(test_helper): add DummyTransport#clear to empty captured events

clear_sentry_events called #clear only if the transport responded to
it; DummyTransport never did, so clearing the testing transport was a
silent no-op. Add #clear that empties the captured events and envelopes
in place (keeping array references valid).

Refs #2951

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(test_helper): anchor setup/teardown to the main hub (#2951)

setup_sentry_test mutated the thread-local hub, but
Sentry.clone_hub_to_current_thread (used by
Sentry::Rack::CaptureExceptions) always clones the *main* hub. After an
intermediate clone the thread-local hub is a clone, so a later
setup_sentry_test reconfigured the clone while the main hub kept a
stale DummyTransport on its base layer. Combined with clear being a
no-op for that transport, an unrelated request's event leaked into the
next test's sentry_events (intermittent under RSpec random ordering).

- setup_sentry_test now binds the base and test clients on the main
  hub and realigns the current thread's hub to it, so direct
  sentry_events reads and request-time clones share one DummyTransport.
- teardown_sentry_test pops the testing layer off the main hub (where
  setup pushed it) instead of the current thread's hub.
- clear_sentry_events now clears every transport reachable from the
  current hub and the main hub (including its base layer) via the new
  sentry_test_transports helper, so no stale DummyTransport survives.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* test(test_helper): add Rack two-request leak regression spec (#2951)

Drives two consecutive requests through the real
Sentry::Rack::CaptureExceptions middleware (which calls
clone_hub_to_current_thread) wrapped in setup_sentry_test/
teardown_sentry_test, asserting the first request's event does not
leak into the second and that each request's event stays observable
via sentry_events. Fails against pre-fix code (second request sees
2 events); passes with the #2951 fix.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* refactor(test_helper): use public Hub#clients instead of @stack ivar (#2951)

Address code review feedback on the #2951 fix:

- Add a documented public Sentry::Hub#clients accessor returning all
  clients across the scope stack, and use it from
  TestHelper#sentry_test_transports instead of reaching into Hub's
  private @stack ivar. This keeps the test helper resilient to future
  Hub internals refactors. Covered by new hub_spec.rb examples.

- Replace the final inline teardown_sentry_test in the #2951 regression
  and Rack consecutive-requests describe blocks with an unconditional
  'after { teardown_sentry_test }' hook, matching the sibling describe
  style so cleanup runs even if an expectation fails mid-example. The
  intentional mid-scenario teardowns remain inline.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: solnic

sentry-ruby/lib/sentry/hub.rb

@@ -54,6 +54,12 @@ def current_client
       current_layer&.client
     end
 
+    # All clients bound across the hub's scope stack, base layer first.
+    # @return [Array<Client>]
+    def clients
+      @stack.map(&:client).compact
+    end
+
     def configuration
       current_client.configuration
     end

sentry-ruby/lib/sentry/test_helper.rb

@@ -37,13 +37,25 @@ def setup_sentry_test(&block)
       # - auto_session_tracking
       block&.call(dummy_config)
 
+      # Install the testing clients on the *main* hub rather than the current
+      # thread's hub. `Sentry.clone_hub_to_current_thread` (used by
+      # Sentry::Rack::CaptureExceptions) always clones the main hub, so if we
+      # only mutated the thread-local hub a request-time clone would observe a
+      # stale transport.
+      main_hub = Sentry.get_main_hub
+
       # the base layer's client should already use the dummy config so nothing will be sent by accident
       base_client = Sentry::Client.new(dummy_config)
-      Sentry.get_current_hub.bind_client(base_client)
+      main_hub.bind_client(base_client)
       # create a new layer so mutations made to the testing scope or configuration could be simply popped later
-      Sentry.get_current_hub.push_scope
+      main_hub.push_scope
       test_client = Sentry::Client.new(dummy_config.dup)
-      Sentry.get_current_hub.bind_client(test_client)
+      main_hub.bind_client(test_client)
+
+      # Realign the current thread's hub with the main hub so direct
+      # `sentry_events` reads and any hub the Rack middleware clones from the
+      # main hub all observe the same DummyTransport.
+      Thread.current.thread_variable_set(Sentry::THREAD_LOCAL, main_hub)
     end
 
     # Clears all stored events and envelopes.
@@ -54,19 +66,29 @@ def teardown_sentry_test
 
       clear_sentry_events
 
-      # pop testing layer created by `setup_sentry_test`
-      # but keep the base layer to avoid nil-pointer errors
+      # pop the testing layer created by `setup_sentry_test` off the *main*
+      # hub (that is where `setup_sentry_test` pushed it), keeping the base
+      # layer to avoid nil-pointer errors. Popping the current thread's hub
+      # would leave the test layer dangling on the main hub, which the next
+      # request-time clone would inherit.
       # TODO: find a way to notify users if they somehow popped the test layer before calling this method
-      if Sentry.get_current_hub.instance_variable_get(:@stack).size > 1
-        Sentry.get_current_hub.pop_scope
+      main_hub = Sentry.get_main_hub
+      if main_hub.instance_variable_get(:@stack).size > 1
+        main_hub.pop_scope
       end
       Sentry::Scope.global_event_processors.clear
     end
 
     def clear_sentry_events
       return unless Sentry.initialized?
 
-      sentry_transport.clear if sentry_transport.respond_to?(:clear)
+      # Clear every transport reachable from the current thread's hub and the
+      # main hub (including its base layer). A request-time clone shares the
+      # main hub's base-layer transport, so clearing only the current
+      # transport would let stale events survive into the next test.
+      sentry_test_transports.each do |transport|
+        transport.clear if transport.respond_to?(:clear)
+      end
 
       if Sentry.configuration.enable_logs && sentry_logger.respond_to?(:clear)
         sentry_logger.clear
@@ -83,6 +105,17 @@ def sentry_transport
       Sentry.get_current_client.transport
     end
 
+    # Every transport reachable from the current thread's hub and the main
+    # hub, across all stack layers. Used by `clear_sentry_events` so a stale
+    # DummyTransport (e.g. the main hub's base layer that a request-time clone
+    # shares) cannot carry leftover events into the next test.
+    # @return [Array<Transport>]
+    def sentry_test_transports
+      [Sentry.get_current_hub, Sentry.get_main_hub].compact.uniq.flat_map do |hub|
+        hub.clients.map(&:transport)
+      end.compact.uniq
+    end
+
     # Returns the captured event objects.
     # @return [Array<Event>]
     def sentry_events

sentry-ruby/lib/sentry/transport/dummy_transport.rb

@@ -18,5 +18,12 @@ def send_event(event)
     def send_envelope(envelope)
       @envelopes << envelope
     end
+
+    # Empties the captured events and envelopes so `TestHelper.clear_sentry_events`
+    # also clears the dummy transport instance
+    def clear
+      @events.clear
+      @envelopes.clear
+    end
   end
 end

sentry-ruby/spec/sentry/hub_spec.rb

@@ -537,6 +537,20 @@
     end
   end
 
+  describe "#clients" do
+    it "returns the only client for a single-layer hub" do
+      expect(subject.clients).to eq([client])
+    end
+
+    it "returns every client across the scope stack, base layer first" do
+      new_client = Sentry::Client.new(configuration)
+      subject.push_scope
+      subject.bind_client(new_client)
+
+      expect(subject.clients).to eq([client, new_client])
+    end
+  end
+
   describe "#pop_scope" do
     it "pops the current scope" do
       prev_scope = subject.current_scope

sentry-ruby/spec/sentry/test_helper_spec.rb

@@ -92,6 +92,82 @@
     end
   end
 
+  describe "event leakage across clone_hub_to_current_thread (regression for #2951)" do
+    after { teardown_sentry_test }
+
+    it "keeps sentry_events empty after setup_sentry_test even when an earlier request captured events through a cloned hub" do
+      setup_sentry_test
+      Sentry.capture_message("event from a previous test")
+      teardown_sentry_test
+
+      Sentry.clone_hub_to_current_thread
+      Sentry.capture_message("event from an unrelated request")
+
+      setup_sentry_test
+
+      expect(sentry_events).to be_empty
+
+      Sentry.clone_hub_to_current_thread
+
+      expect(sentry_events).to be_empty
+    end
+  end
+
+  describe "request-captured events remain observable after clone_hub_to_current_thread" do
+    after { teardown_sentry_test }
+
+    it "still exposes events captured through a hub the Rack middleware cloned after setup_sentry_test" do
+      setup_sentry_test
+
+      Sentry.clone_hub_to_current_thread
+      Sentry.capture_message("event from the request")
+
+      expect(sentry_events.map(&:message)).to include("event from the request")
+    end
+  end
+
+  describe "Sentry::Rack::CaptureExceptions across consecutive requests (regression for #2951)", when: :rack_available? do
+    after { teardown_sentry_test }
+
+    # Drives a single request through the real Rack middleware. The middleware
+    # calls Sentry.clone_hub_to_current_thread before handing off to the app,
+    # exactly like a Rails request spec would.
+    def perform_request(exception_message)
+      exception = RuntimeError.new(exception_message)
+      app = lambda do |env|
+        env["rack.exception"] = exception
+        [200, {}, ["ok"]]
+      end
+      stack = Sentry::Rack::CaptureExceptions.new(app)
+      stack.call(Rack::MockRequest.env_for("/#{exception_message}"))
+    end
+
+    def captured_exception_messages
+      sentry_events.map { |event| event.to_h.dig(:exception, :values, 0, :value) }
+    end
+
+    it "isolates each request's events and keeps them observable via sentry_events" do
+      # First request, wrapped in the test helper just like a request spec.
+      setup_sentry_test
+      perform_request("first-request")
+      messages = captured_exception_messages
+      expect(messages.size).to eq(1)
+      expect(messages.first).to include("first-request")
+      teardown_sentry_test
+
+      # Second request: a fresh setup must not see the first request's event,
+      # even though the Rack middleware clones the main hub on every request.
+      setup_sentry_test
+      expect(sentry_events).to be_empty
+
+      perform_request("second-request")
+      messages = captured_exception_messages
+      expect(messages.size).to eq(1)
+      expect(messages.first).to include("second-request")
+      expect(messages).not_to include(a_string_including("first-request"))
+    end
+  end
+
   describe "#teardown_sentry_test" do
     before do
       setup_sentry_test