fix(sidekiq): enrich failures before ActiveJob runs

Author: solnic

sentry-ruby/lib/sentry/scope.rb

@@ -218,6 +218,10 @@ def set_span(span)
       @span = span
     end
 
+    def clear_span
+      @span = nil
+    end
+
     # @!macro set_user
     def set_user(user_hash)
       check_argument_type!(user_hash, Hash)

sentry-sidekiq/lib/sentry/sidekiq/sentry_context_middleware.rb

@@ -49,10 +49,28 @@ def call(worker, job, queue)
 
       def perform_through_active_job(job, sidekiq_job)
         args = job["args"]
-        job["args"] = job_extension.active_job_args(sidekiq_job, sidekiq_config: sidekiq_config)
-        yield
+        original_hub = Sentry.get_current_hub_internal
+        Sentry.clone_hub_to_current_thread
+
+        Sentry.with_scope do |scope|
+          scope.clear_span
+          consumer.apply_scope_data(scope, sidekiq_job, default_scope_data: job_extension.scope_data(sidekiq_job))
+          scope.set_transaction_name(job_extension.transaction_name(job), source: :task)
+          Sentry.continue_trace(job_extension.extract_trace_headers(sidekiq_job))
+          job["args"] = job_extension.active_job_args(sidekiq_job, sidekiq_config: sidekiq_config)
+
+          begin
+            yield
+          rescue => e
+            context = { context: JobExtension::JOB_ERROR_CONTEXT, job: sidekiq_job }
+            context[:jobstr] = ::Sidekiq.dump_json(sidekiq_job) if JobExtension::JOB_STRING_IN_ERROR_CONTEXT
+            ErrorHandler.new.call(e, context, sidekiq_config)
+            raise
+          end
+        end
       ensure
         job["args"] = args
+        Sentry.set_current_hub_internal(original_hub)
       end
 
       def consumer

sentry-sidekiq/spec/isolated/active_job_spec.rb

@@ -395,6 +395,59 @@ def reported_executions(job_class, error, adapter_skipped:)
     end
   end
 
+  context "when the queued ActiveJob class cannot be loaded" do
+    let(:traces_sample_rate) { nil }
+
+    [nil, 1.0].each do |sample_rate|
+      it "preserves native error enrichment and the incoming trace at sample rate #{sample_rate.inspect}" do
+        Sentry.configuration.traces_sample_rate = sample_rate
+        worker_transaction = Sentry.start_transaction(name: "worker", op: "test")
+        Sentry.get_main_hub.current_scope.set_span(worker_transaction) if worker_transaction
+
+        message = sidekiq_message(
+          parity_job,
+          retry: false,
+          tags: ["marvel"],
+          sentry_user: { "id" => "42" },
+          trace_propagation_headers: { "sentry-trace" => "#{"a" * 32}-#{"b" * 16}-0" }
+        )
+        message["wrapped"] = "RemovedJob"
+        message["args"].first["job_class"] = "RemovedJob"
+
+        native_errors = process(message, adapter_skipped: true).grep(Sentry::ErrorEvent)
+        active_job_errors = process(message, adapter_skipped: false).grep(Sentry::ErrorEvent)
+
+        expect(native_errors.size).to eq(1)
+        expect(active_job_errors.size).to eq(1)
+        expect(active_job_errors.first.tags).to include(native_errors.first.tags)
+        expect(active_job_errors.first.user).to eq(native_errors.first.user)
+        expect(active_job_errors.first.contexts.dig(:trace, :trace_id)).to eq("a" * 32)
+      end
+    end
+
+    it "restores the worker hub and payload after a failure before perform_now" do
+      skip_sidekiq_adapter(false)
+      message = sidekiq_message(parity_job, retry: false)
+      message["args"].first["job_class"] = "RemovedJob"
+      original_args = message["args"]
+      original_payload = Marshal.load(Marshal.dump(original_args))
+      hub = Sentry.get_current_hub
+      Sentry.set_tags(worker: "outside")
+
+      expect do
+        Sentry::Sidekiq::SentryContextServerMiddleware.new.call(nil, message, "events") do
+          ActiveJob::Base.execute(message["args"].first)
+        end
+      end.to raise_error(NameError)
+
+      expect(message["args"]).to equal(original_args)
+      expect(message["args"]).to eq(original_payload)
+      expect(Sentry.get_current_hub).to equal(hub)
+      expect(Sentry.get_current_scope.tags).to eq(worker: "outside")
+      expect(transport.events.grep(Sentry::ErrorEvent).size).to eq(1)
+    end
+  end
+
   context "with a separate running Sidekiq configuration", skip: !WITH_SIDEKIQ_7 do
     let(:running_config) do
       Sidekiq::Config.new(max_retries: 5).tap do |config|