WIP

Author: solnic

.devcontainer/.env.example

@@ -12,5 +12,11 @@ SENTRY_E2E_SVELTE_APP_PORT=4001
 SENTRY_E2E_RAILS_APP_URL="http://localhost:4000"
 SENTRY_E2E_SVELTE_APP_URL="http://localhost:4001"
 
+# ActiveJob queue adapter under test: async | inline | sidekiq | resque | delayed_job
+SENTRY_E2E_ACTIVE_JOB_ADAPTER="async"
+
+# Redis for the sidekiq/resque adapters (the Compose service is named "redis")
+REDIS_URL="redis://redis:6379"
+
 # Faster builds with compose
 COMPOSE_BAKE=true

.devcontainer/docker-compose.yml

@@ -25,6 +25,9 @@ services:
     command: ["mise", "run", "e2e:serve"]
     environment:
       BUNDLE_PATH: /home/sentry/bundle
+    depends_on:
+      redis:
+        condition: service_healthy
     volumes:
       - ..:/workspace/sentry:cached
       - bundle-gems:/home/sentry/bundle
@@ -38,6 +41,11 @@ services:
       - ALLOW_EMPTY_PASSWORD=yes
     ports:
       - "6379:6379"
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 2s
+      timeout: 3s
+      retries: 10
 
 volumes:
   bundle-gems:

.github/workflows/e2e_tests.yml

@@ -17,18 +17,24 @@ concurrency:
 
 jobs:
   e2e-tests:
-    name: e2e tests
+    name: e2e tests (ruby ${{ matrix.ruby.flavor }}, ${{ matrix.adapter }})
     runs-on: ubuntu-latest
-    timeout-minutes: 5
+    timeout-minutes: 8
 
     strategy:
       fail-fast: false
       matrix:
-        include:
-          - ruby_version: "3.4.9"
+        ruby:
+          - version: "3.4.9"
             flavor: "3.4"
-          - ruby_version: "4.0.3"
+          - version: "4.0.3"
             flavor: "4.0"
+        adapter:
+          - async
+          - inline
+          - sidekiq
+          - resque
+          - delayed_job
 
     steps:
       - name: Checkout code
@@ -42,9 +48,10 @@ jobs:
         run: |
           cd .devcontainer
           cp .env.example .env
-          echo "RUBY_VERSION=${{ matrix.ruby_version }}" >> .env
-          echo "DOCKER_IMAGE=ghcr.io/getsentry/sentry-ruby-devcontainer-${{ matrix.flavor }}" >> .env
+          echo "RUBY_VERSION=${{ matrix.ruby.version }}" >> .env
+          echo "DOCKER_IMAGE=ghcr.io/getsentry/sentry-ruby-devcontainer-${{ matrix.ruby.flavor }}" >> .env
           echo "DOCKER_TAG=${{ steps.devcontainer-version.outputs.version }}" >> .env
+          echo "SENTRY_E2E_ACTIVE_JOB_ADAPTER=${{ matrix.adapter }}" >> .env
 
       - name: Log in to GHCR
         uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3
@@ -54,7 +61,7 @@ jobs:
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Pull test container image
-        run: docker pull ghcr.io/getsentry/sentry-ruby-devcontainer-${{ matrix.flavor }}:${{ steps.devcontainer-version.outputs.version }}
+        run: docker pull ghcr.io/getsentry/sentry-ruby-devcontainer-${{ matrix.ruby.flavor }}:${{ steps.devcontainer-version.outputs.version }}
 
       - name: Restore node_modules cache
         uses: actions/cache@6f8efc29b200d32929f49075959781ed54ec270c # v3
@@ -114,7 +121,7 @@ jobs:
         if: failure()
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
-          name: e2e-test-logs-ruby-${{ matrix.ruby_version }}
+          name: e2e-test-logs-ruby-${{ matrix.ruby.version }}-${{ matrix.adapter }}
           path: |
             log/sentry_debug_events.log
           retention-days: 7

.mise.toml

@@ -14,6 +14,10 @@ run = "cd spec/apps/rails-mini && bundle exec ruby app.rb"
 description = "Start the svelte-mini e2e app"
 run = "cd spec/apps/svelte-mini && npm run dev"
 
+[tasks."e2e:worker"]
+description = "Start the rails-mini ActiveJob worker (sidekiq/resque/delayed_job; idles for async/inline)"
+run = "cd spec/apps/rails-mini && bundle exec ruby worker.rb"
+
 [tasks."e2e:serve"]
 description = "Start all e2e apps in parallel"
-depends = ["e2e:rails", "e2e:svelte"]
+depends = ["e2e:rails", "e2e:svelte", "e2e:worker"]

spec/apps/rails-mini/Gemfile

@@ -13,3 +13,6 @@ gem 'sqlite3'
 
 gem 'sentry-ruby', path: Pathname(__dir__).join("../../..").realpath
 gem 'sentry-rails', path: Pathname(__dir__).join("../../..").realpath
+gem 'sidekiq'
+gem 'resque'
+gem 'delayed_job_active_record'

spec/apps/rails-mini/app.rb

@@ -10,6 +10,13 @@
 require "action_controller/railtie"
 require "active_record/railtie"
 require "active_job/railtie"
+require "time"
+
+# Point the broker-backed adapters at Redis. Sidekiq reads REDIS_URL on
+# its own; Resque does not, so wire it up explicitly. Defaults to a local
+# Redis when REDIS_URL is unset (e.g. running outside Docker Compose).
+redis_url = ENV.fetch("REDIS_URL", "redis://localhost:6379")
+Resque.redis = redis_url if defined?(Resque)
 
 class RailsMiniApp < Rails::Application
   config.hosts = nil
@@ -20,6 +27,29 @@ class RailsMiniApp < Rails::Application
   config.api_only = true
   config.force_ssl = false
 
+  # Select the ActiveJob queue adapter from the environment. This must be
+  # assigned in the application body (not inside an `initializer` block):
+  # ActiveJob's own `active_job.set_configs` initializer reads
+  # `config.active_job.queue_adapter` and applies it via an `on_load`
+  # hook that fires during boot, before app-defined initializers run. An
+  # assignment made from an initializer would therefore be a silent no-op
+  # and every adapter would fall back to the default :async.
+  SUPPORTED_ACTIVE_JOB_ADAPTERS = {
+    "async" => :async,
+    "inline" => :inline,
+    "sidekiq" => :sidekiq,
+    "resque" => :resque,
+    "delayed_job" => :delayed_job
+  }.freeze
+
+  adapter_name = ENV.fetch("SENTRY_E2E_ACTIVE_JOB_ADAPTER", "async").to_s.downcase
+  unless SUPPORTED_ACTIVE_JOB_ADAPTERS.key?(adapter_name)
+    raise "Unsupported ActiveJob adapter: #{adapter_name}"
+  end
+
+  config.active_job.queue_adapter = SUPPORTED_ACTIVE_JOB_ADAPTERS[adapter_name]
+  config.x.active_job_adapter_name = adapter_name
+
   def debug_log_path
     @log_path ||= begin
       path = Pathname(__dir__).join("../../../log")
@@ -211,48 +241,64 @@ def set_cors_headers
 class JobsController < ActionController::Base
   before_action :set_cors_headers
 
-  def sample_job
-    job = SampleJob.perform_later("Hello from Rails mini app!")
+  JOB_CLASSES = {
+    "sample" => SampleJob,
+    "database" => DatabaseJob,
+    "failing" => FailingJob
+  }.freeze
 
-    Sentry.logger.info("SampleJob enqueued", job_id: job.job_id)
+  def enqueue
+    job_type = params[:job_type] || params[:id] || params[:job] || "sample"
+    job_class = JOB_CLASSES[job_type.to_s]
+    raise ActionController::BadRequest.new("Unsupported job type: #{job_type}") unless job_class
 
-    render json: {
-      message: "SampleJob enqueued successfully",
-      job_id: job.job_id,
-      job_class: job.class.name
-    }
-  end
+    args = Array(params[:args] || [])
+    args = JSON.parse(args) if args.is_a?(String) && args.strip.start_with?("[")
 
-  def database_job
-    title = params[:title] || "Test Post from Job"
-    job = DatabaseJob.perform_later(title)
+    job = schedule_job(job_class, args)
 
-    Sentry.logger.info("DatabaseJob enqueued", job_id: job.job_id, post_title: title)
+    Sentry.logger.info(
+      "#{job_class.name} enqueued",
+      job_id: job.job_id,
+      job_class: job.class.name,
+      args: args
+    )
 
-    render json: {
-      message: "DatabaseJob enqueued successfully",
+    response_body = {
+      message: "#{job_class.name} enqueued successfully",
       job_id: job.job_id,
       job_class: job.class.name,
-      post_title: title
+      args: args
     }
-  end
 
-  def failing_job
-    should_fail = params[:should_fail] != "false"
-    job = FailingJob.perform_later(should_fail)
+    if job_type.to_s == "database"
+      response_body[:post_title] = args[0] || "Test Post from Job"
+    elsif job_type.to_s == "failing"
+      response_body[:should_fail] = args.empty? ? true : args.first
+    end
 
-    Sentry.logger.info("FailingJob enqueued", job_id: job.job_id, should_fail: should_fail)
+    render json: response_body
+  end
 
+  def active_job_adapter
     render json: {
-      message: "FailingJob enqueued successfully",
-      job_id: job.job_id,
-      job_class: job.class.name,
-      should_fail: should_fail
+      adapter: Rails.configuration.x.active_job_adapter_name,
+      queue_adapter: ActiveJob::Base.queue_adapter.class.name
     }
   end
 
   private
 
+  def schedule_job(job_class, args)
+    if params[:wait_seconds].present?
+      job_class.set(wait: params[:wait_seconds].to_i.seconds).perform_later(*args)
+    elsif params[:wait_until].present?
+      job_class.set(wait_until: Time.parse(params[:wait_until])).perform_later(*args)
+    else
+      job_class.perform_later(*args)
+    end
+  end
+
   def set_cors_headers
     response.headers['Access-Control-Allow-Origin'] = '*'
     response.headers['Access-Control-Allow-Methods'] = 'GET, POST, PUT, DELETE, OPTIONS'
@@ -262,23 +308,45 @@ def set_cors_headers
 
 RailsMiniApp.initialize!
 
-ActiveRecord::Schema.define do
-  create_table :posts, force: true do |t|
-    t.string :title, null: false
-    t.text :content
-    t.timestamps
-  end
+# The web process owns schema setup. The worker (worker.rb) boots the same
+# app in parallel and sets SENTRY_E2E_SKIP_DB_SETUP=true to skip this block,
+# avoiding a concurrent `force: true` drop/create race on the shared SQLite
+# file; it waits for these tables to appear before processing jobs.
+unless ENV["SENTRY_E2E_SKIP_DB_SETUP"] == "true"
+  ActiveRecord::Schema.define do
+    create_table :posts, force: true do |t|
+      t.string :title, null: false
+      t.text :content
+      t.timestamps
+    end
+
+    create_table :users, force: true do |t|
+      t.string :name, null: false
+      t.string :email
+      t.timestamps
+    end
 
-  create_table :users, force: true do |t|
-    t.string :name, null: false
-    t.string :email
-    t.timestamps
+    # Backing store for the :delayed_job adapter. Created unconditionally so
+    # the same schema works regardless of which adapter the worker uses.
+    create_table :delayed_jobs, force: true do |t|
+      t.integer :priority, default: 0, null: false
+      t.integer :attempts, default: 0, null: false
+      t.text :handler, null: false
+      t.text :last_error
+      t.datetime :run_at
+      t.datetime :locked_at
+      t.datetime :failed_at
+      t.string :locked_by
+      t.string :queue
+      t.timestamps null: true
+    end
+    add_index :delayed_jobs, [:priority, :run_at], name: "delayed_jobs_priority"
   end
-end
 
-Post.create!(title: "Welcome Post", content: "Welcome to the Rails mini app!")
-Post.create!(title: "Sample Post", content: "This is a sample post for testing.")
-User.create!(name: "Test User", email: "test@example.com")
+  Post.create!(title: "Welcome Post", content: "Welcome to the Rails mini app!")
+  Post.create!(title: "Sample Post", content: "This is a sample post for testing.")
+  User.create!(name: "Test User", email: "test@example.com")
+end
 
 RailsMiniApp.routes.draw do
   get '/health', to: 'events#health'
@@ -291,9 +359,9 @@ def set_cors_headers
   post '/posts', to: 'posts#create'
   get '/posts/:id', to: 'posts#show'
 
-  post '/jobs/sample', to: 'jobs#sample_job'
-  post '/jobs/database', to: 'jobs#database_job'
-  post '/jobs/failing', to: 'jobs#failing_job'
+  post '/jobs/enqueue', to: 'jobs#enqueue'
+  post '/jobs/:job_type', to: 'jobs#enqueue'
+  get '/jobs/adapter', to: 'jobs#active_job_adapter'
 
   match '*path', to: proc { |env|
     [200, {

spec/apps/rails-mini/worker.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Background worker entrypoint for the worker-based ActiveJob adapters
+# (:sidekiq, :resque, :delayed_job). These adapters enqueue onto an
+# external broker (Redis / the DB) and rely on a separate process to
+# execute the job. The worker boots the same Rails + Sentry app as the
+# web process, so the job's consumer transaction is emitted into the
+# shared debug-transport log the e2e suite reads.
+#
+# :async and :inline run inside the web process and need no worker here.
+
+adapter = ENV.fetch("SENTRY_E2E_ACTIVE_JOB_ADAPTER", "async").to_s.downcase
+
+# The web process owns schema setup; the worker must not recreate the tables
+# concurrently. Both processes share the same SQLite file.
+ENV["SENTRY_E2E_SKIP_DB_SETUP"] = "true"
+
+# Sidekiq ships its own CLI that boots the app via -r; hand off to it
+# directly instead of double-booting Rails in this process. SENTRY_E2E_SKIP_DB_SETUP
+# is inherited by the exec'd process, so it skips schema setup too.
+if adapter == "sidekiq"
+  exec("bundle", "exec", "sidekiq", "-r", "./app.rb", "-c", "2", "-q", "default")
+end
+
+require_relative "app"
+
+# Wait for the web process to finish creating the schema before consuming
+# jobs (the `posts` table is created in the same block as the others).
+60.times do
+  break if ActiveRecord::Base.connection.table_exists?(:posts)
+
+  sleep 0.5
+end
+
+case adapter
+when "resque"
+  # Process every queue in-process (no fork) so the Sentry SDK state set
+  # up at boot stays intact while the job runs.
+  queues = ENV.fetch("QUEUES", "*").split(",")
+  ENV["FORK_PER_JOB"] ||= "false"
+  worker = Resque::Worker.new(*queues)
+  worker.work(ENV.fetch("RESQUE_INTERVAL", "0.5").to_f)
+when "delayed_job"
+  Delayed::Worker.new(sleep_delay: 0.5, quiet: false).start
+else
+  # :async and :inline run jobs inside the web process. Stay alive as an
+  # idle no-op so this stays a uniform, long-running service under process
+  # supervisors (mise `e2e:serve`, Docker Compose) regardless of adapter.
+  warn "No external worker needed for adapter: #{adapter.inspect}; idling."
+  sleep
+end

spec/features/active_job_tracing_spec.rb

@@ -67,7 +67,7 @@ def wait_for_trace(timeout: 10)
 
       transactions.each do |http_txn|
         next unless http_txn.dig("contexts", "trace", "op") == "http.server"
-        next unless http_txn["transaction"] =~ /JobsController#sample_job/
+        next unless http_txn["transaction"] =~ /JobsController#enqueue/
 
         trace_id = http_txn.dig("contexts", "trace", "trace_id")
         job_txn = transactions.find do |t|