update: add appsignal instrumentation only

Author: HNKhoi2410

idempotency.gemspec

@@ -39,4 +39,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'dry-monitor'
   spec.add_dependency 'msgpack'
   spec.add_dependency 'redis'
+
+  spec.add_dependency 'appsignal', '>= 1.3.0'
 end

lib/idempotency.rb

@@ -31,7 +31,6 @@ def self.notifier
 
   setting :observability do
     setting :appsignal_enabled, default: false
-    setting :sentry_enabled, default: false
   end
 
   setting :default_lock_expiry, default: 300 # 5 minutes
@@ -149,36 +148,16 @@ def unquote(str)
     end
   end
 
-  # rubocop:disable Metrics/AbcSize
-  def with_apm_instrumentation(name, action, &block)
-    # Build nested instrumentation layers from innermost to outermost
-    instrumented_block = block
-
-    # Wrap with Sentry if enabled
-    if config.observability.sentry_enabled && defined?(Sentry)
-      instrumented_block = lambda do
-        Sentry.with_child_span(op: name, description: action) do |_span|
-          block.call
-        end
-      rescue StandardError => e
-        Sentry.capture_exception(e)
-        raise
-      end
-    end
-
-    # Wrap with AppSignal if enabled (outermost layer)
+  def with_apm_instrumentation(name, action, &)
     if config.observability.appsignal_enabled && defined?(Appsignal)
       Appsignal.instrument(name, action) do
-        instrumented_block.call
+        yield
       rescue StandardError => e
         Appsignal.set_error(e)
         raise
       end
     else
-      # Execute the (potentially Sentry-wrapped) block
-      instrumented_block.call
+      yield
     end
   end
-  # rubocop:enable Metrics/AbcSize
 end
-# rubocop:enable Metrics/ClassLength

spec/idempotency/apm_instrumentation_spec.rb

@@ -20,13 +20,12 @@
     let(:block_result) { 'test_result' }
     let(:test_block) { -> { block_result } }
 
-    context 'when neither AppSignal nor Sentry is enabled' do
+    context 'when AppSignal is not enabled' do
       before do
         Idempotency.configure do |config|
           config.redis_pool = redis_pool
           config.logger = Logger.new(nil)
           config.observability.appsignal_enabled = false
-          config.observability.sentry_enabled = false
         end
       end
 
@@ -48,7 +47,6 @@
           config.redis_pool = redis_pool
           config.logger = Logger.new(nil)
           config.observability.appsignal_enabled = true
-          config.observability.sentry_enabled = false
         end
       end
 
@@ -97,52 +95,6 @@
       end
     end
 
-    context 'when Sentry is enabled' do
-      let(:mock_span) { double('Sentry::Span') }
-
-      before do
-        stub_const('Sentry', double('Sentry'))
-        allow(Sentry).to receive(:with_child_span).and_yield(mock_span)
-
-        Idempotency.configure do |config|
-          config.redis_pool = redis_pool
-          config.logger = Logger.new(nil)
-          config.observability.appsignal_enabled = false
-          config.observability.sentry_enabled = true
-        end
-      end
-
-      it 'wraps execution in Sentry child span' do
-        expect(Sentry).to receive(:with_child_span).with(
-          op: 'test.operation',
-          description: 'test'
-        ).and_yield(mock_span)
-
-        result = idempotency.send(:with_apm_instrumentation, 'test.operation', 'test') do
-          test_block.call
-        end
-
-        expect(result).to eq(block_result)
-      end
-
-      it 'captures exceptions with Sentry and re-raises' do
-        test_error = StandardError.new('test error')
-
-        expect(Sentry).to receive(:with_child_span).with(
-          op: 'test.operation',
-          description: 'test'
-        ).and_yield(mock_span)
-
-        expect(Sentry).to receive(:capture_exception).with(test_error)
-
-        expect do
-          idempotency.send(:with_apm_instrumentation, 'test.operation', 'test') do
-            raise test_error
-          end
-        end.to raise_error(StandardError, 'test error')
-      end
-    end
-
     context 'when AppSignal is enabled but not defined' do
       before do
         hide_const('Appsignal')
@@ -151,28 +103,6 @@
           config.redis_pool = redis_pool
           config.logger = Logger.new(nil)
           config.observability.appsignal_enabled = true
-          config.observability.sentry_enabled = false
-        end
-      end
-
-      it 'falls back to executing without instrumentation' do
-        result = idempotency.send(:with_apm_instrumentation, 'test.operation', 'test') do
-          test_block.call
-        end
-
-        expect(result).to eq(block_result)
-      end
-    end
-
-    context 'when Sentry is enabled but not defined' do
-      before do
-        hide_const('Sentry')
-
-        Idempotency.configure do |config|
-          config.redis_pool = redis_pool
-          config.logger = Logger.new(nil)
-          config.observability.appsignal_enabled = false
-          config.observability.sentry_enabled = true
         end
       end
 
@@ -184,67 +114,5 @@
         expect(result).to eq(block_result)
       end
     end
-
-    context 'when both AppSignal and Sentry are enabled' do
-      let(:mock_span) { double('Sentry::Span') }
-
-      before do
-        stub_const('Appsignal', double('Appsignal'))
-        stub_const('Sentry', double('Sentry'))
-        allow(Appsignal).to receive(:instrument).and_yield
-        allow(Sentry).to receive(:with_child_span).and_yield(mock_span)
-
-        Idempotency.configure do |config|
-          config.redis_pool = redis_pool
-          config.logger = Logger.new(nil)
-          config.observability.appsignal_enabled = true
-          config.observability.sentry_enabled = true
-        end
-      end
-
-      it 'instruments in both AppSignal and Sentry (nested)' do
-        # Expect Sentry to be set up (inner layer)
-        expect(Sentry).to receive(:with_child_span).with(
-          op: 'test.operation',
-          description: 'test'
-        ).and_yield(mock_span)
-
-        # Expect AppSignal to wrap everything (outer layer)
-        expect(Appsignal).to receive(:instrument).with(
-          'test.operation',
-          'test'
-        ).and_yield
-
-        result = idempotency.send(:with_apm_instrumentation, 'test.operation', 'test') do
-          test_block.call
-        end
-
-        expect(result).to eq(block_result)
-      end
-
-      it 'reports errors to both AppSignal and Sentry' do
-        test_error = StandardError.new('test error')
-
-        # Expect Sentry to capture the exception (inner layer)
-        expect(Sentry).to receive(:with_child_span).with(
-          op: 'test.operation',
-          description: 'test'
-        ).and_yield(mock_span)
-        expect(Sentry).to receive(:capture_exception).with(test_error)
-
-        # Expect AppSignal to also capture the exception (outer layer)
-        expect(Appsignal).to receive(:instrument).with(
-          'test.operation',
-          'test'
-        ).and_yield
-        expect(Appsignal).to receive(:set_error).with(test_error)
-
-        expect do
-          idempotency.send(:with_apm_instrumentation, 'test.operation', 'test') do
-            raise test_error
-          end
-        end.to raise_error(StandardError, 'test error')
-      end
-    end
   end
 end