Drop async configuration

Author: st0012

sentry-ruby/lib/sentry/background_worker.rb

@@ -22,10 +22,7 @@ def initialize(configuration)
       @shutdown_callback = nil
 
       @executor =
-        if configuration.async
-          log_debug("config.async is set, BackgroundWorker is disabled")
-          Concurrent::ImmediateExecutor.new
-        elsif @number_of_threads == 0
+        if @number_of_threads == 0
           log_debug("config.background_worker_threads is set to 0, all events will be sent synchronously")
           Concurrent::ImmediateExecutor.new
         else

sentry-ruby/lib/sentry/client.rb

@@ -56,9 +56,7 @@ def capture_event(event, scope, hint = {})
         return
       end
 
-      if async_block = configuration.async
-        dispatch_async_event(async_block, event, hint)
-      elsif configuration.background_worker_threads != 0 && hint.fetch(:background, true)
+      if configuration.background_worker_threads != 0 && hint.fetch(:background, true)
         queued = dispatch_background_event(event, hint)
         transport.record_lost_event(:queue_overflow, event_type) unless queued
       else
@@ -180,28 +178,5 @@ def dispatch_background_event(event, hint)
         send_event(event, hint)
       end
     end
-
-    def dispatch_async_event(async_block, event, hint)
-      # We have to convert to a JSON-like hash, because background job
-      # processors (esp ActiveJob) may not like weird types in the event hash
-
-      event_hash =
-        begin
-          event.to_json_compatible
-        rescue => e
-          log_error("Converting #{event.type} (#{event.event_id}) to JSON compatible hash failed", e, debug: configuration.debug)
-          return
-        end
-
-      if async_block.arity == 2
-        hint = JSON.parse(JSON.generate(hint))
-        async_block.call(event_hash, hint)
-      else
-        async_block.call(event_hash)
-      end
-    rescue => e
-      log_error("Async #{event_hash["type"]} sending failed", e, debug: configuration.debug)
-      send_event(event, hint)
-    end
   end
 end

sentry-ruby/lib/sentry/configuration.rb

@@ -21,13 +21,6 @@ class Configuration
     # @return [Regexp, nil]
     attr_accessor :app_dirs_pattern
 
-    # Provide an object that responds to `call` to send events asynchronously.
-    # E.g.: lambda { |event| Thread.new { Sentry.send_event(event) } }
-    #
-    # @deprecated It will be removed in the next major release. Please read https://github.com/getsentry/sentry-ruby/issues/1522 for more information
-    # @return [Proc, nil]
-    attr_reader :async
-
     # to send events in a non-blocking way, sentry-ruby has its own background worker
     # by default, the worker holds a thread pool that has [the number of processors] threads
     # but you can configure it with this configuration option
@@ -62,7 +55,6 @@ class Configuration
     # @example
     #   config.before_send = lambda do |event, hint|
     #     # skip ZeroDivisionError exceptions
-    #     # note: hint[:exception] would be a String if you use async callback
     #     if hint[:exception].is_a?(ZeroDivisionError)
     #       nil
     #     else
@@ -329,22 +321,6 @@ def dsn=(value)
 
     alias server= dsn=
 
-    def async=(value)
-      check_callable!("async", value)
-
-      log_warn <<~MSG
-
-        sentry-ruby now sends events asynchronously by default with its background worker (supported since 4.1.0).
-        The `config.async` callback has become redundant while continuing to cause issues.
-        (The problems of `async` are detailed in https://github.com/getsentry/sentry-ruby/issues/1522)
-
-        Therefore, we encourage you to remove it and let the background worker take care of async job sending.
-      It's deprecation is planned in the next major release (6.0), which is scheduled around the 3rd quarter of 2022.
-      MSG
-
-      @async = value
-    end
-
     def breadcrumbs_logger=(logger)
       loggers =
         if logger.is_a?(Array)

sentry-ruby/spec/sentry/background_worker_spec.rb

@@ -10,22 +10,6 @@
   end
 
   describe "#initialize" do
-    context "when config.async is set" do
-      before do
-        configuration.async = proc {}
-      end
-
-      it "initializes a background_worker with ImmediateExecutor" do
-        worker = described_class.new(configuration)
-
-        expect(string_io.string).to match(
-          /config.async is set, BackgroundWorker is disabled/
-        )
-
-        expect(worker.instance_variable_get(:@executor)).to be_a(Concurrent::ImmediateExecutor)
-      end
-    end
-
     context "when config.background_worker_threads is set" do
       it "initializes a background worker with correct number of threads and queue size" do
         worker = described_class.new(configuration)

sentry-ruby/spec/sentry/client/event_sending_spec.rb

@@ -52,84 +52,6 @@
       end
     end
 
-    context 'with config.async set' do
-      let(:async_block) do
-        lambda do |event|
-          subject.send_event(event)
-        end
-      end
-
-      around do |example|
-        prior_async = configuration.async
-        configuration.async = async_block
-        example.run
-        configuration.async = prior_async
-      end
-
-      it "executes the given block" do
-        expect(async_block).to receive(:call).and_call_original
-
-        returned = subject.capture_event(event, scope)
-
-        expect(returned).to be_a(Sentry::ErrorEvent)
-        expect(subject.transport.events.first).to eq(event.to_json_compatible)
-      end
-
-      it "doesn't call the async block if not allow sending events" do
-        allow(configuration).to receive(:sending_allowed?).and_return(false)
-
-        expect(async_block).not_to receive(:call)
-
-        returned = subject.capture_event(event, scope)
-
-        expect(returned).to eq(nil)
-      end
-
-      context "with to json conversion failed" do
-        let(:logger) { ::Logger.new(string_io) }
-        let(:string_io) { StringIO.new }
-        let(:event) { subject.event_from_message("Bad data '\x80\xF8'") }
-
-        it "does not mask the exception" do
-          configuration.logger = logger
-
-          subject.capture_event(event, scope)
-
-          expect(string_io.string).to include("Converting event (#{event.event_id}) to JSON compatible hash failed: source sequence is illegal/malformed utf-8")
-        end
-      end
-
-      context "with nil as value (the legacy way to disable it)" do
-        let(:async_block) { nil }
-
-        it "doesn't cause any issue" do
-          returned = subject.capture_event(event, scope, { background: false })
-
-          expect(returned).to be_a(Sentry::ErrorEvent)
-          expect(subject.transport.events.first).to eq(event)
-        end
-      end
-
-      context "with 2 arity block" do
-        let(:async_block) do
-          lambda do |event, hint|
-            event["tags"]["hint"] = hint
-            subject.send_event(event)
-          end
-        end
-
-        it "serializes hint and supplies it as the second argument" do
-          expect(configuration.async).to receive(:call).and_call_original
-
-          returned = subject.capture_event(event, scope, { foo: "bar" })
-
-          expect(returned).to be_a(Sentry::ErrorEvent)
-          event = subject.transport.events.first
-          expect(event.dig("tags", "hint")).to eq({ "foo" => "bar" })
-        end
-      end
-    end
-
     context "with background_worker enabled (default)" do
       before do
         Sentry.background_worker = Sentry::BackgroundWorker.new(configuration)
@@ -303,12 +225,6 @@
     let(:event) { subject.event_from_message(message) }
 
     describe "#capture_event" do
-      around do |example|
-        prior_async = configuration.async
-        example.run
-        configuration.async = prior_async
-      end
-
       context "when scope.apply_to_event returns nil" do
         before do
           scope.add_event_processor do |event, hint|
@@ -400,28 +316,6 @@
           expect(string_io.string).to match(/Unreported Event: Test message/)
         end
       end
-
-      context "when config.async causes error" do
-        before do
-          expect(subject).to receive(:send_event)
-        end
-
-        it "swallows Redis related error and send the event synchronizely" do
-          configuration.async = -> (_, _) { raise Redis::ConnectionError }
-
-          subject.capture_event(event, scope)
-
-          expect(string_io.string).to match(/Async event sending failed: Redis::ConnectionError/)
-        end
-
-        it "swallows and logs the exception" do
-          configuration.async = -> (_, _) { raise TypeError }
-
-          subject.capture_event(event, scope)
-
-          expect(string_io.string).to match(/Async event sending failed: TypeError/)
-        end
-      end
     end
 
     describe "#send_event" do

sentry-ruby/spec/sentry/configuration_spec.rb

@@ -131,19 +131,6 @@
     end
   end
 
-  context 'configuring for async' do
-    it 'should be configurable to send events async' do
-      subject.async = ->(_e) { :ok }
-      expect(subject.async.call('event')).to eq(:ok)
-    end
-  end
-
-  it 'raises error when setting async to anything other than callable or nil' do
-    subject.async = -> {}
-    subject.async = nil
-    expect { subject.async = true }.to raise_error(ArgumentError, "async must be callable (or nil to disable)")
-  end
-
   it 'raises error when setting before_send to anything other than callable or nil' do
     subject.before_send = -> {}
     subject.before_send = nil