test(rails): run distributed_tracing shared example against :solid_queue

Opts the SolidQueue adapter spec into the distributed_tracing meta so
all five tracing examples (producer span, trace propagation, messaging
span data, user propagation, worker hub isolation) run against
:solid_queue alongside the existing :test adapter coverage.

Two SolidQueue-specific harness adjustments were needed to make this
work on the SQLite-backed test setup:

- drain only wraps in travel_to when the caller passes an explicit
  `at:`. Without this, the inner travel_to(Time.current) collides with
  the outer travel block in messaging_span_data.rb's latency assertion.

- worker_hub_isolation.rb now spawns its threads through a `worker_thread`
  harness hook (default = `Thread.new`). The :solid_queue spec overrides
  this hook to allocate an isolated SQLite shard per spawned thread via
  `connects_to(shards: ...)` + `connected_to(shard:)`. Each worker
  thread reads/writes its own SolidQueue tables, eliminating the
  SQLite3::BusyException that two concurrent perform_later/drain
  pipelines on the shared test DB would otherwise raise. The contract
  the spec enforces — concurrent jobs in different threads do not
  cross-pollute Sentry scope — holds the same way it does on :test.

Verified GREEN on Rails 6.1 (SQ skipped, :test adapter only),
7.1, and 8.1 via ./bin/test --version.

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

Author: solnic

sentry-rails/spec/active_job/solid_queue_spec.rb

@@ -9,8 +9,61 @@
     include ActiveSupport::Testing::TimeHelpers
     include_context "active_job backend harness", adapter: :solid_queue
 
+    WORKER_SHARD_COUNT = 4
+
     def boot_adapter(_adapter)
       Sentry::Rails::Test::Application.load_queue_schema
+
+      install_worker_shards
+    end
+
+    # Sets up `WORKER_SHARD_COUNT` independent SQLite databases as AR
+    # shards alongside the primary test DB. Each worker thread spawned
+    # by `worker_thread` claims its own shard, so concurrent perform_later
+    # / drain calls from different threads never contend on the same
+    # SQLite file (which would otherwise raise SQLite3::BusyException).
+    def install_worker_shards
+      base_dir = Sentry::Rails::Test::Application.root_path.join("db")
+      worker_paths = (1..WORKER_SHARD_COUNT).map { |i| base_dir.join("queue_worker_#{i}.sqlite3") }
+
+      # Wipe any previous run's files so each spec starts fresh.
+      worker_paths.each { |p| File.unlink(p) if File.exist?(p) }
+
+      primary_db = Sentry::Rails::Test::Application.db_path.to_s
+      configs = { "primary" => { "adapter" => "sqlite3", "database" => primary_db, "timeout" => 5000 } }
+      worker_paths.each_with_index do |path, i|
+        configs["worker_#{i + 1}"] = { "adapter" => "sqlite3", "database" => path.to_s, "timeout" => 5000 }
+      end
+
+      ActiveRecord::Base.configurations = { "test" => configs }
+
+      shards = { default: { writing: :primary } }
+      WORKER_SHARD_COUNT.times { |i| shards[:"worker_#{i + 1}"] = { writing: :"worker_#{i + 1}" } }
+      ActiveRecord::Base.connects_to(shards: shards)
+
+      # Load the queue schema into each worker shard so its tables exist.
+      WORKER_SHARD_COUNT.times do |i|
+        ActiveRecord::Base.connected_to(shard: :"worker_#{i + 1}") do
+          load Sentry::Rails::Test::Application.queue_schema_file
+        end
+      end
+
+      @worker_shard_counter = 0
+      @worker_shard_mutex = Mutex.new
+    end
+
+    def next_worker_shard
+      @worker_shard_mutex.synchronize do
+        @worker_shard_counter = (@worker_shard_counter % WORKER_SHARD_COUNT) + 1
+        :"worker_#{@worker_shard_counter}"
+      end
+    end
+
+    def worker_thread(&block)
+      shard = next_worker_shard
+      Thread.new do
+        ActiveRecord::Base.connected_to(shard: shard, &block)
+      end
     end
 
     def reset_adapter(_adapter)
@@ -33,12 +86,18 @@ def drain(at: nil)
         name: "spec-#{SecureRandom.hex(4)}"
       )
 
-      travel_to(at || Time.current) do
+      run = lambda do
         SolidQueue::ScheduledExecution.dispatch_next_batch(100)
         SolidQueue::ReadyExecution.claim("*", 100, process.id).each(&:perform)
       end
+
+      # Only wrap in travel_to when the caller explicitly asks for a future
+      # time — otherwise nested travel_to (e.g. from a spec that already
+      # called `travel`) raises.
+      at ? travel_to(at, &run) : run.call
     end
 
     it_behaves_like "a Sentry-instrumented ActiveJob backend"
+    it_behaves_like "an ActiveJob backend that supports distributed tracing"
   end
 end