appsignal 3.6.0 → 3.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6402d39c536a0e4fe970163c92d3207cad1af89c279d0bec8494abf90844434c
-  data.tar.gz: c989b01ded89a0c2643ba5b4bb02d24b02012ee25383b451fee192eae59ab611
+  metadata.gz: 0fe85cc642a413909a757ef143180354523bf05327df1f0eae2c0a29a1ce4570
+  data.tar.gz: ae2bd9370beec37c374885e5bf10b5316394243ed73038f5d377553734789597
 SHA512:
-  metadata.gz: 65908eb0b138011eccd79c0fe0de47f3c2b150bc333eb656fde66f541529fe1801d0404a6dadfc875cbbf53b442613970dabe221fc2ae52fafd55927bb408bc8
-  data.tar.gz: 2852aeb49f06d45606bc58a81c0e344b62326340aff7c81f363a2f081346b2147fd60eb7c38a0065c1dfed94ca4f148b1b866aafc6bada1734a4d1911746e07a
+  metadata.gz: 042fcd15607fa4ea121422ae7064181d90f2654d51dcea8f553aa3a6af8cafedc9ad60e5d6a3e74f15c701109d1aae65fb5ac66d1e597ca2dc83e91ec6342e52
+  data.tar.gz: 9e732c7b94dfa76013a8def22d31202feb6c7e4ecffb74a74408e2787ed8ae7b98fd8477b9a2af7242edc35d912d65f2c60a9228ef2ce019574082919ae4d622

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.6.2
+
+_Published on 2024-03-08._
+
+### Fixed
+
+- [c3921865](https://github.com/appsignal/appsignal-ruby/commit/c392186573a72fd9afe22299fabcd14dcfe96139) patch - Revert Rack middleware changes (see [changelog](https://github.com/appsignal/appsignal-ruby/blob/main/CHANGELOG.md#360)) to fix issues relating to Unicorn broken pipe errors and multiple requests merging into a single sample.
+
+## 3.6.1
+
+_Published on 2024-03-05._
+
+### Added
+
+- [8974d201](https://github.com/appsignal/appsignal-ruby/commit/8974d20144407fce7a274ebaeb771ef76705d901) patch - Add `activejob_report_errors` config option. When set to `"none"`, ActiveJob jobs will no longer report errors. This can be used in combination with [custom exception reporting](https://docs.appsignal.com/ruby/instrumentation/exception-handling.html). By default, the config option has the value `"all"`, which reports all errors.
+
 ## 3.6.0
 
 _Published on 2024-02-26._

data/lib/appsignal/config.rb

@@ -11,6 +11,7 @@ module Appsignal
     include Appsignal::Utils::DeprecationMessage
 
     DEFAULT_CONFIG = {
+      :activejob_report_errors => "all",
       :ca_file_path => File.expand_path(File.join("../../../resources/cacert.pem"), __FILE__),
       :debug => false,
       :dns_servers => [],
@@ -65,6 +66,7 @@ module Appsignal
 
     ENV_TO_KEY_MAPPING = {
       "APPSIGNAL_ACTIVE" => :active,
+      "APPSIGNAL_ACTIVE_JOB_REPORT_ERRORS" => :activejob_report_errors,
       "APPSIGNAL_APP_NAME" => :name,
       "APPSIGNAL_BIND_ADDRESS" => :bind_address,
       "APPSIGNAL_CA_FILE_PATH" => :ca_file_path,
@@ -112,6 +114,7 @@ module Appsignal
     }.freeze
     # @api private
     ENV_STRING_KEYS = %w[
+      APPSIGNAL_ACTIVE_JOB_REPORT_ERRORS
       APPSIGNAL_APP_NAME
       APPSIGNAL_BIND_ADDRESS
       APPSIGNAL_CA_FILE_PATH

data/lib/appsignal/hooks/active_job.rb

@@ -56,7 +56,7 @@ module Appsignal
           super
         rescue Exception => exception # rubocop:disable Lint/RescueException
           job_status = :failed
-          transaction.set_error(exception)
+          transaction_set_error(transaction, exception)
           raise exception
         ensure
           if transaction
@@ -82,6 +82,14 @@ module Appsignal
               tags.merge(:status => :processed)
           end
         end
+
+        private
+
+        def transaction_set_error(transaction, exception)
+          return if Appsignal.config[:activejob_report_errors] == "none"
+
+          transaction.set_error(exception)
+        end
       end
 
       module ActiveJobHelpers

data/lib/appsignal/rack/generic_instrumentation.rb

@@ -16,9 +16,7 @@ module Appsignal
         if Appsignal.active?
           call_with_appsignal_monitoring(env)
         else
-          nil_transaction = Appsignal::Transaction::NilTransaction.new
-          status, headers, obody = @app.call(env)
-          [status, headers, Appsignal::Rack::BodyWrapper.wrap(obody, nil_transaction)]
+          @app.call(env)
         end
       end
 
@@ -29,30 +27,19 @@ module Appsignal
           Appsignal::Transaction::HTTP_REQUEST,
           request
         )
-        # We need to complete the transaction if there is an exception inside the `call`
-        # of the app. If there isn't one and the app returns us a Rack response triplet, we let
-        # the BodyWrapper complete the transaction when #close gets called on it
-        # (guaranteed by the webserver)
-        complete_transaction_without_body = false
         begin
           Appsignal.instrument("process_action.generic") do
-            status, headers, obody = @app.call(env)
-            [status, headers, Appsignal::Rack::BodyWrapper.wrap(obody, transaction)]
+            @app.call(env)
           end
         rescue Exception => error # rubocop:disable Lint/RescueException
           transaction.set_error(error)
-          complete_transaction_without_body = true
           raise error
         ensure
-          default_action = env["appsignal.route"] || env["appsignal.action"] || "unknown"
-          transaction.set_action_if_nil(default_action)
+          transaction.set_action_if_nil(env["appsignal.route"] || "unknown")
           transaction.set_metadata("path", request.path)
           transaction.set_metadata("method", request.request_method)
           transaction.set_http_or_background_queue_start
-
-          # Transaction gets completed when the body gets read out, except in cases when
-          # the app failed before returning us the Rack response triplet.
-          Appsignal::Transaction.complete_current! if complete_transaction_without_body
+          Appsignal::Transaction.complete_current!
         end
       end
     end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -16,9 +16,7 @@ module Appsignal
         if Appsignal.active?
           call_with_appsignal_monitoring(env)
         else
-          nil_transaction = Appsignal::Transaction::NilTransaction.new
-          status, headers, obody = @app.call(env)
-          [status, headers, Appsignal::Rack::BodyWrapper.wrap(obody, nil_transaction)]
+          @app.call(env)
         end
       end
 
@@ -30,17 +28,10 @@ module Appsignal
           request,
           :params_method => :filtered_parameters
         )
-        # We need to complete the transaction if there is an exception exception inside the `call`
-        # of the app. If there isn't one and the app returns us a Rack response triplet, we let
-        # the BodyWrapper complete the transaction when #close gets called on it
-        # (guaranteed by the webserver)
-        complete_transaction_without_body = false
         begin
-          status, headers, obody = @app.call(env)
-          [status, headers, Appsignal::Rack::BodyWrapper.wrap(obody, transaction)]
+          @app.call(env)
         rescue Exception => error # rubocop:disable Lint/RescueException
           transaction.set_error(error)
-          complete_transaction_without_body = true
           raise error
         ensure
           controller = env["action_controller.instance"]
@@ -54,10 +45,7 @@ module Appsignal
           rescue => error
             Appsignal.internal_logger.error("Unable to report HTTP request method: '#{error}'")
           end
-
-          # Transaction gets completed when the body gets read out, except in cases when
-          # the app failed before returning us the Rack response triplet.
-          Appsignal::Transaction.complete_current! if complete_transaction_without_body
+          Appsignal::Transaction.complete_current!
         end
       end
 

data/lib/appsignal/rack/sinatra_instrumentation.rb

@@ -42,9 +42,7 @@ module Appsignal
         if Appsignal.active?
           call_with_appsignal_monitoring(env)
         else
-          nil_transaction = Appsignal::Transaction::NilTransaction.new
-          status, headers, obody = @app.call(env)
-          [status, headers, Appsignal::Rack::BodyWrapper.wrap(obody, nil_transaction)]
+          @app.call(env)
         end
       end
 
@@ -58,19 +56,12 @@ module Appsignal
           request,
           options
         )
-        # We need to complete the transaction if there is an exception exception inside the `call`
-        # of the app. If there isn't one and the app returns us a Rack response triplet, we let
-        # the BodyWrapper complete the transaction when #close gets called on it
-        # (guaranteed by the webserver)
-        complete_transaction_without_body = false
         begin
           Appsignal.instrument("process_action.sinatra") do
-            status, headers, obody = @app.call(env)
-            [status, headers, Appsignal::Rack::BodyWrapper.wrap(obody, transaction)]
+            @app.call(env)
           end
         rescue Exception => error # rubocop:disable Lint/RescueException
           transaction.set_error(error)
-          complete_transaction_without_body = true
           raise error
         ensure
           # If raise_error is off versions of Sinatra don't raise errors, but store
@@ -82,10 +73,7 @@ module Appsignal
           transaction.set_metadata("path", request.path)
           transaction.set_metadata("method", request.request_method)
           transaction.set_http_or_background_queue_start
-
-          # Transaction gets completed when the body gets read out, except in cases when
-          # the app failed before returning us the Rack response triplet.
-          Appsignal::Transaction.complete_current! if complete_transaction_without_body
+          Appsignal::Transaction.complete_current!
         end
       end
 

data/lib/appsignal/rack/streaming_listener.rb

@@ -16,9 +16,7 @@ module Appsignal
         if Appsignal.active?
           call_with_appsignal_monitoring(env)
         else
-          nil_transaction = Appsignal::Transaction::NilTransaction.new
-          status, headers, obody = @app.call(env)
-          [status, headers, Appsignal::Rack::BodyWrapper.wrap(obody, nil_transaction)]
+          @app.call(env)
         end
       end
 
@@ -30,35 +28,46 @@ module Appsignal
           request
         )
 
-        # We need to complete the transaction if there is an exception exception inside the `call`
-        # of the app. If there isn't one and the app returns us a Rack response triplet, we let
-        # the BodyWrapper complete the transaction when #close gets called on it
-        # (guaranteed by the webserver)
-        complete_transaction_without_body = false
-
         # Instrument a `process_action`, to set params/action name
-        begin
+        status, headers, body =
           Appsignal.instrument("process_action.rack") do
-            status, headers, obody = @app.call(env)
-            [status, headers, Appsignal::Rack::BodyWrapper.wrap(obody, transaction)]
+            @app.call(env)
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            transaction.set_error(e)
+            raise e
+          ensure
+            transaction.set_action_if_nil(env["appsignal.action"])
+            transaction.set_metadata("path", request.path)
+            transaction.set_metadata("method", request.request_method)
+            transaction.set_http_or_background_queue_start
           end
-        rescue Exception => error # rubocop:disable Lint/RescueException
-          transaction.set_error(error)
-          complete_transaction_without_body = true
-          raise error
-        ensure
-          transaction.set_action_if_nil(env["appsignal.action"])
-          transaction.set_metadata("path", request.path)
-          transaction.set_metadata("method", request.request_method)
-          transaction.set_http_or_background_queue_start
 
-          # Transaction gets completed when the body gets read out, except in cases when
-          # the app failed before returning us the Rack response triplet.
-          Appsignal::Transaction.complete_current! if complete_transaction_without_body
-        end
+        # Wrap the result body with our StreamWrapper
+        [status, headers, StreamWrapper.new(body, transaction)]
       end
     end
   end
 
-  StreamWrapper = Rack::EnumerableBodyWrapper
+  class StreamWrapper
+    def initialize(stream, transaction)
+      @stream = stream
+      @transaction = transaction
+    end
+
+    def each(&block)
+      @stream.each(&block)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      @transaction.set_error(e)
+      raise e
+    end
+
+    def close
+      @stream.close if @stream.respond_to?(:close)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      @transaction.set_error(e)
+      raise e
+    ensure
+      Appsignal::Transaction.complete_current!
+    end
+  end
 end

data/lib/appsignal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Appsignal
-  VERSION = "3.6.0"
+  VERSION = "3.6.2"
 end

data/lib/appsignal.rb

@@ -305,6 +305,5 @@ require "appsignal/garbage_collection"
 require "appsignal/integrations/railtie" if defined?(::Rails)
 require "appsignal/transaction"
 require "appsignal/version"
-require "appsignal/rack/body_wrapper"
 require "appsignal/rack/generic_instrumentation"
 require "appsignal/transmitter"

data/spec/lib/appsignal/config_spec.rb

@@ -152,6 +152,7 @@ describe Appsignal::Config do
     it "merges with the default config" do
       expect(config.config_hash).to eq(
         :active                         => true,
+        :activejob_report_errors        => "all",
         :ca_file_path                   => File.join(resources_dir, "cacert.pem"),
         :debug                          => false,
         :dns_servers                    => [],

data/spec/lib/appsignal/hooks/activejob_spec.rb

@@ -222,6 +222,31 @@ if DependencyHelper.active_job_present?
         expect(events).to eq(expected_perform_events)
       end
 
+      context "with activejob_report_errors set to none" do
+        it "does not report the error" do
+          Appsignal.config = project_fixture_config("production")
+          Appsignal.config[:activejob_report_errors] = "none"
+
+          # Other calls we're testing in another test
+          allow(Appsignal).to receive(:increment_counter)
+          tags = { :queue => queue }
+          expect(Appsignal).to receive(:increment_counter)
+            .with("active_job_queue_job_count", 1, tags.merge(:status => :failed))
+          expect(Appsignal).to receive(:increment_counter)
+            .with("active_job_queue_job_count", 1, tags.merge(:status => :processed))
+
+          expect do
+            perform_job(ActiveJobErrorTestJob)
+          end.to raise_error(RuntimeError, "uh oh")
+
+          transaction = last_transaction
+          transaction_hash = transaction.to_h
+          expect(transaction_hash).to include(
+            "error" => nil
+          )
+        end
+      end
+
       if DependencyHelper.rails_version >= Gem::Version.new("5.0.0")
         context "with priority" do
           before do

data/spec/lib/appsignal/rack/generic_instrumentation_spec.rb

@@ -50,7 +50,7 @@ describe Appsignal::Rack::GenericInstrumentation do
       expect(app).to receive(:call).with(env)
     end
 
-    context "with an exception raised from call()", :error => true do
+    context "with an exception", :error => true do
       let(:error) { ExampleException }
       let(:app) do
         double.tap do |d|
@@ -58,9 +58,8 @@ describe Appsignal::Rack::GenericInstrumentation do
         end
       end
 
-      it "records the exception and completes the transaction" do
+      it "records the exception" do
         expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
-        expect(Appsignal::Transaction).to receive(:complete_current!)
       end
     end
 

data/spec/lib/appsignal/rack/rails_instrumentation_spec.rb

@@ -65,8 +65,7 @@ if DependencyHelper.rails_present?
 
     describe "#call_with_appsignal_monitoring" do
       def run
-        _status, _headers, body = middleware.call(env)
-        body.close # Rack will always call close() on the body
+        middleware.call(env)
       end
 
       it "calls the wrapped app" do
@@ -127,8 +126,7 @@ if DependencyHelper.rails_present?
           end
         end
 
-        it "records the exception and completes the transaction" do
-          expect(Appsignal::Transaction).to receive(:complete_current!)
+        it "records the exception" do
           expect { run }.to raise_error(error)
 
           transaction_hash = last_transaction.to_h

data/spec/lib/appsignal/rack/sinatra_instrumentation_spec.rb

@@ -3,9 +3,7 @@ if DependencyHelper.sinatra_present?
 
   module SinatraRequestHelpers
     def make_request(env)
-      _status, _headers, body = middleware.call(env)
-      # Close the body so that the transaction gets completed
-      body&.close
+      middleware.call(env)
     end
 
     def make_request_with_error(env, error)

data/spec/lib/appsignal/rack/streaming_listener_spec.rb

@@ -90,11 +90,10 @@ describe Appsignal::Rack::StreamingListener do
     context "with an exception in the instrumentation call" do
       let(:error) { ExampleException }
 
-      it "should add the exception to the transaction and complete the transaction" do
+      it "should add the exception to the transaction" do
         allow(app).to receive(:call).and_raise(error)
 
         expect(transaction).to receive(:set_error).with(error)
-        expect(Appsignal::Transaction).to receive(:complete_current!).and_call_original
 
         expect do
           listener.call_with_appsignal_monitoring(env)
@@ -102,19 +101,64 @@ describe Appsignal::Rack::StreamingListener do
       end
     end
 
-    it "should wrap the response body in a wrapper" do
+    it "should wrap the body in a wrapper" do
+      expect(Appsignal::StreamWrapper).to receive(:new)
+        .with("body", transaction)
+        .and_return(wrapper)
+
       body = listener.call_with_appsignal_monitoring(env)[2]
 
-      expect(body).to be_kind_of(Appsignal::Rack::BodyWrapper)
+      expect(body).to be_a(Appsignal::StreamWrapper)
     end
   end
 end
 
 describe Appsignal::StreamWrapper do
-  it ".new returns an EnumerableWrapper" do
-    fake_body = double(:each => nil)
-    fake_txn = double
-    stream_wrapper = Appsignal::StreamWrapper.new(fake_body, fake_txn)
-    expect(stream_wrapper).to be_kind_of(Appsignal::Rack::EnumerableBodyWrapper)
+  let(:stream)      { double }
+  let(:transaction) do
+    Appsignal::Transaction.create(SecureRandom.uuid, Appsignal::Transaction::HTTP_REQUEST, {})
+  end
+  let(:wrapper) { Appsignal::StreamWrapper.new(stream, transaction) }
+
+  describe "#each" do
+    it "calls the original stream" do
+      expect(stream).to receive(:each)
+
+      wrapper.each
+    end
+
+    context "when #each raises an error" do
+      let(:error) { ExampleException }
+
+      it "records the exception" do
+        allow(stream).to receive(:each).and_raise(error)
+
+        expect(transaction).to receive(:set_error).with(error)
+
+        expect { wrapper.send(:each) }.to raise_error(error)
+      end
+    end
+  end
+
+  describe "#close" do
+    it "closes the original stream and completes the transaction" do
+      expect(stream).to receive(:close)
+      expect(Appsignal::Transaction).to receive(:complete_current!)
+
+      wrapper.close
+    end
+
+    context "when #close raises an error" do
+      let(:error) { ExampleException }
+
+      it "records the exception and completes the transaction" do
+        allow(stream).to receive(:close).and_raise(error)
+
+        expect(transaction).to receive(:set_error).with(error)
+        expect(transaction).to receive(:complete)
+
+        expect { wrapper.send(:close) }.to raise_error(error)
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 3.6.2
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-26 00:00:00.000000000 Z
+date: 2024-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -268,7 +268,6 @@ files:
 - lib/appsignal/probes/helpers.rb
 - lib/appsignal/probes/mri.rb
 - lib/appsignal/probes/sidekiq.rb
-- lib/appsignal/rack/body_wrapper.rb
 - lib/appsignal/rack/generic_instrumentation.rb
 - lib/appsignal/rack/rails_instrumentation.rb
 - lib/appsignal/rack/sinatra_instrumentation.rb
@@ -367,7 +366,6 @@ files:
 - spec/lib/appsignal/probes/gvl_spec.rb
 - spec/lib/appsignal/probes/mri_spec.rb
 - spec/lib/appsignal/probes/sidekiq_spec.rb
-- spec/lib/appsignal/rack/body_wrapper_spec.rb
 - spec/lib/appsignal/rack/generic_instrumentation_spec.rb
 - spec/lib/appsignal/rack/rails_instrumentation_spec.rb
 - spec/lib/appsignal/rack/sinatra_instrumentation_spec.rb
@@ -453,7 +451,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.15
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Logs performance and exception data from your app to appsignal.com

data/lib/appsignal/rack/body_wrapper.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module Appsignal
-  # @api private
-  module Rack
-    class BodyWrapper
-      def self.wrap(original_body, appsignal_transaction)
-        # The logic of how Rack treats a response body differs based on which methods
-        # the body responds to. This means that to support the Rack 3.x spec in full
-        # we need to return a wrapper which matches the API of the wrapped body as closely
-        # as possible. Pick the wrapper from the most specific to the least specific.
-        # See https://github.com/rack/rack/blob/main/SPEC.rdoc#the-body-
-        #
-        # What is important is that our Body wrapper responds to the same methods Rack
-        # (or a webserver) would be checking and calling, and passes through that functionality
-        # to the original body. This can be done using delegation via i.e. SimpleDelegate
-        # but we also need "close" to get called correctly so that the Appsignal transaction
-        # gets completed - which will not happen, for example, when #to_ary gets called
-        # just on the delegated Rack body.
-        #
-        # This comment https://github.com/rails/rails/pull/49627#issuecomment-1769802573
-        # is of particular interest to understand why this has to be somewhat complicated.
-        if original_body.respond_to?(:to_path)
-          PathableBodyWrapper.new(original_body, appsignal_transaction)
-        elsif original_body.respond_to?(:to_ary)
-          ArrayableBodyWrapper.new(original_body, appsignal_transaction)
-        elsif !original_body.respond_to?(:each) && original_body.respond_to?(:call)
-          # This body only supports #call, so we must be running a Rack 3 application
-          # It is possible that a body exposes both `each` and `call` in the hopes of
-          # being backwards-compatible with both Rack 3.x and Rack 2.x, however
-          # this is not going to work since the SPEC says that if both are available,
-          # `each` should be used and `call` should be ignored.
-          # So for that case we can drop by to our default EnumerableBodyWrapper
-          CallableBodyWrapper.new(original_body, appsignal_transaction)
-        else
-          EnumerableBodyWrapper.new(original_body, appsignal_transaction)
-        end
-      end
-
-      def initialize(body, appsignal_transaction)
-        @body_already_closed = false
-        @body = body
-        @transaction = appsignal_transaction
-      end
-
-      # This must be present in all Rack bodies and will be called by the serving adapter
-      def close
-        # The @body_already_closed check is needed so that if `to_ary`
-        # of the body has already closed itself (as prescribed) we do not
-        # attempt to close it twice
-        if !@body_already_closed && @body.respond_to?(:close)
-          Appsignal.instrument("response_body_close.rack") { @body.close }
-        end
-        @body_already_closed = true
-      rescue Exception => error # rubocop:disable Lint/RescueException
-        @transaction.set_error(error)
-        raise error
-      ensure
-        complete_transaction!
-      end
-
-      def complete_transaction!
-        # We need to call the Transaction class method and not
-        # @transaction.complete because the transaction is still
-        # thread-local and it needs to remove itself from the
-        # thread variables correctly, which does not happen on
-        # Transaction#complete.
-        #
-        # In the future it would be a good idea to ensure
-        # that the current transaction is the same as @transaction,
-        # or allow @transaction to complete itself and remove
-        # itself from Thread.current
-        Appsignal::Transaction.complete_current!
-      end
-    end
-
-    # The standard Rack body wrapper which exposes "each" for iterating
-    # over the response body. This is supported across all 3 major Rack
-    # versions.
-    #
-    # @api private
-    class EnumerableBodyWrapper < BodyWrapper
-      def each(&blk)
-        # This is a workaround for the Rails bug when there was a bit too much
-        # eagerness in implementing to_ary, see:
-        # https://github.com/rails/rails/pull/44953
-        # https://github.com/rails/rails/pull/47092
-        # https://github.com/rails/rails/pull/49627
-        # https://github.com/rails/rails/issues/49588
-        # While the Rack SPEC does not mandate `each` to be callable
-        # in a blockless way it is still a good idea to have it in place.
-        return enum_for(:each) unless block_given?
-
-        Appsignal.instrument("process_response_body.rack", "Process Rack response body (#each)") do
-          @body.each(&blk)
-        end
-      rescue Exception => error # rubocop:disable Lint/RescueException
-        @transaction.set_error(error)
-        raise error
-      end
-    end
-
-    # The callable response bodies are a new Rack 3.x feature, and would not work
-    # with older Rack versions. They must not respond to `each` because
-    # "If it responds to each, you must call each and not call". This is why
-    # it inherits from BodyWrapper directly and not from EnumerableBodyWrapper
-    #
-    # @api private
-    class CallableBodyWrapper < BodyWrapper
-      def call(stream)
-        # `stream` will be closed by the app we are calling, no need for us
-        # to close it ourselves
-        Appsignal.instrument("process_response_body.rack", "Process Rack response body (#call)") do
-          @body.call(stream)
-        end
-      rescue Exception => error # rubocop:disable Lint/RescueException
-        @transaction.set_error(error)
-        raise error
-      end
-    end
-
-    # "to_ary" takes precedence over "each" and allows the response body
-    # to be read eagerly. If the body supports that method, it takes precedence
-    # over "each":
-    # "Middleware may call to_ary directly on the Body and return a new Body in its place"
-    # One could "fold" both the to_ary API and the each() API into one Body object, but
-    # to_ary must also call "close" after it executes - and in the Rails implementation
-    # this pecularity was not handled properly.
-    #
-    # @api private
-    class ArrayableBodyWrapper < EnumerableBodyWrapper
-      def to_ary
-        @body_already_closed = true
-        Appsignal.instrument(
-          "process_response_body.rack",
-          "Process Rack response body (#to_ary)"
-        ) do
-          @body.to_ary
-        end
-      rescue Exception => error # rubocop:disable Lint/RescueException
-        @transaction.set_error(error)
-        raise error
-      ensure
-        # We do not call "close" on ourselves as the only action
-        # we need to complete is completing the transaction.
-        complete_transaction!
-      end
-    end
-
-    # Having "to_path" on a body allows Rack to serve out a static file, or to
-    # pass that file to the downstream webserver for sending using X-Sendfile
-    class PathableBodyWrapper < EnumerableBodyWrapper
-      def to_path
-        Appsignal.instrument("response_body_to_path.rack") { @body.to_path }
-      rescue Exception => error # rubocop:disable Lint/RescueException
-        @transaction.set_error(error)
-        raise error
-      end
-    end
-  end
-end

data/spec/lib/appsignal/rack/body_wrapper_spec.rb

@@ -1,220 +0,0 @@
-describe Appsignal::Rack::BodyWrapper do
-  let(:nil_txn) { Appsignal::Transaction::NilTransaction.new }
-
-  describe "with a body that supports all possible features" do
-    it "reduces the supported methods to just each()" do
-      # which is the safest thing to do, since the body is likely broken
-      fake_body = double(:each => nil, :call => nil, :to_ary => [], :to_path => "/tmp/foo.bin",
-        :close => nil)
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect(wrapped).to respond_to(:each)
-      expect(wrapped).not_to respond_to(:to_ary)
-      expect(wrapped).not_to respond_to(:call)
-      expect(wrapped).to respond_to(:close)
-    end
-  end
-
-  describe "with a body only supporting each()" do
-    it "wraps with appropriate class" do
-      fake_body = double
-      allow(fake_body).to receive(:each)
-
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect(wrapped).to respond_to(:each)
-      expect(wrapped).not_to respond_to(:to_ary)
-      expect(wrapped).not_to respond_to(:call)
-      expect(wrapped).to respond_to(:close)
-    end
-
-    it "reads out the body in full using each" do
-      fake_body = double
-      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect { |b| wrapped.each(&b) }.to yield_successive_args("a", "b", "c")
-    end
-
-    it "returns an Enumerator if each() gets called without a block" do
-      fake_body = double
-      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
-
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      enum = wrapped.each
-      expect(enum).to be_kind_of(Enumerator)
-      expect { |b| enum.each(&b) }.to yield_successive_args("a", "b", "c")
-    end
-
-    it "sets the exception raised inside each() into the Appsignal transaction" do
-      fake_body = double
-      expect(fake_body).to receive(:each).once.and_raise(Exception.new("Oops"))
-
-      txn = double("Appsignal transaction", "nil_transaction?" => false)
-      expect(txn).to receive(:set_error).once.with(instance_of(Exception))
-
-      wrapped = described_class.wrap(fake_body, txn)
-      expect do
-        expect { |b| wrapped.each(&b) }.to yield_control
-      end.to raise_error(/Oops/)
-    end
-
-    it "closes the body and the transaction when it gets closed" do
-      fake_body = double
-      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
-
-      txn = double("Appsignal transaction", "nil_transaction?" => false)
-      expect(Appsignal::Transaction).to receive(:complete_current!).once
-
-      wrapped = described_class.wrap(fake_body, txn)
-      expect { |b| wrapped.each(&b) }.to yield_successive_args("a", "b", "c")
-      expect { wrapped.close }.not_to raise_error
-    end
-  end
-
-  describe "with a body supporting both each() and call" do
-    it "wraps with the wrapper that conceals call() and exposes each" do
-      fake_body = double
-      allow(fake_body).to receive(:each)
-      allow(fake_body).to receive(:call)
-
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect(wrapped).to respond_to(:each)
-      expect(wrapped).not_to respond_to(:to_ary)
-      expect(wrapped).not_to respond_to(:call)
-      expect(wrapped).not_to respond_to(:to_path)
-      expect(wrapped).to respond_to(:close)
-    end
-  end
-
-  describe "with a body supporting both to_ary and each" do
-    let(:fake_body) { double(:each => nil, :to_ary => []) }
-    it "wraps with appropriate class" do
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect(wrapped).to respond_to(:each)
-      expect(wrapped).to respond_to(:to_ary)
-      expect(wrapped).not_to respond_to(:call)
-      expect(wrapped).not_to respond_to(:to_path)
-      expect(wrapped).to respond_to(:close)
-    end
-
-    it "reads out the body in full using each" do
-      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
-
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect { |b| wrapped.each(&b) }.to yield_successive_args("a", "b", "c")
-    end
-
-    it "sets the exception raised inside each() into the Appsignal transaction" do
-      expect(fake_body).to receive(:each).once.and_raise(Exception.new("Oops"))
-
-      txn = double("Appsignal transaction", "nil_transaction?" => false)
-      expect(txn).to receive(:set_error).once.with(instance_of(Exception))
-
-      wrapped = described_class.wrap(fake_body, txn)
-      expect do
-        expect { |b| wrapped.each(&b) }.to yield_control
-      end.to raise_error(/Oops/)
-    end
-
-    it "reads out the body in full using to_ary" do
-      expect(fake_body).to receive(:to_ary).and_return(["one", "two", "three"])
-
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect(wrapped.to_ary).to eq(["one", "two", "three"])
-    end
-
-    it "sends the exception raised inside to_ary() into the Appsignal and closes txn" do
-      fake_body = double
-      allow(fake_body).to receive(:each)
-      expect(fake_body).to receive(:to_ary).once.and_raise(Exception.new("Oops"))
-      expect(fake_body).not_to receive(:close) # Per spec we expect the body has closed itself
-
-      txn = double("Appsignal transaction", "nil_transaction?" => false)
-      expect(txn).to receive(:set_error).once.with(instance_of(Exception))
-      expect(Appsignal::Transaction).to receive(:complete_current!).once
-
-      wrapped = described_class.wrap(fake_body, txn)
-      expect { wrapped.to_ary }.to raise_error(/Oops/)
-    end
-  end
-
-  describe "with a body supporting both to_path and each" do
-    let(:fake_body) { double(:each => nil, :to_path => nil) }
-
-    it "wraps with appropriate class" do
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect(wrapped).to respond_to(:each)
-      expect(wrapped).not_to respond_to(:to_ary)
-      expect(wrapped).not_to respond_to(:call)
-      expect(wrapped).to respond_to(:to_path)
-      expect(wrapped).to respond_to(:close)
-    end
-
-    it "reads out the body in full using each()" do
-      expect(fake_body).to receive(:each).once.and_yield("a").and_yield("b").and_yield("c")
-
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect { |b| wrapped.each(&b) }.to yield_successive_args("a", "b", "c")
-    end
-
-    it "sets the exception raised inside each() into the Appsignal transaction" do
-      expect(fake_body).to receive(:each).once.and_raise(Exception.new("Oops"))
-
-      txn = double("Appsignal transaction", "nil_transaction?" => false)
-      expect(txn).to receive(:set_error).once.with(instance_of(Exception))
-
-      wrapped = described_class.wrap(fake_body, txn)
-      expect do
-        expect { |b| wrapped.each(&b) }.to yield_control
-      end.to raise_error(/Oops/)
-    end
-
-    it "sets the exception raised inside to_path() into the Appsignal transaction" do
-      allow(fake_body).to receive(:to_path).once.and_raise(Exception.new("Oops"))
-
-      txn = double("Appsignal transaction", "nil_transaction?" => false)
-      expect(txn).to receive(:set_error).once.with(instance_of(Exception))
-      expect(txn).not_to receive(:complete) # gets called by the caller via close()
-
-      wrapped = described_class.wrap(fake_body, txn)
-      expect { wrapped.to_path }.to raise_error(/Oops/)
-    end
-
-    it "exposes to_path to the sender" do
-      allow(fake_body).to receive(:to_path).and_return("/tmp/file.bin")
-
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect(wrapped.to_path).to eq("/tmp/file.bin")
-    end
-  end
-
-  describe "with a body only supporting call()" do
-    let(:fake_body) { double(:call => nil) }
-    it "wraps with appropriate class" do
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect(wrapped).not_to respond_to(:each)
-      expect(wrapped).not_to respond_to(:to_ary)
-      expect(wrapped).to respond_to(:call)
-      expect(wrapped).not_to respond_to(:to_path)
-      expect(wrapped).to respond_to(:close)
-    end
-
-    it "passes the stream into the call() of the body" do
-      fake_rack_stream = double("stream")
-      expect(fake_body).to receive(:call).with(fake_rack_stream)
-
-      wrapped = described_class.wrap(fake_body, nil_txn)
-      expect { wrapped.call(fake_rack_stream) }.not_to raise_error
-    end
-
-    it "sets the exception raised inside call() into the Appsignal transaction" do
-      fake_rack_stream = double
-      allow(fake_body).to receive(:call).with(fake_rack_stream).and_raise(Exception.new("Oopsie"))
-
-      txn = double("Appsignal transaction", "nil_transaction?" => false)
-      expect(txn).to receive(:set_error).once.with(instance_of(Exception))
-      expect(txn).not_to receive(:complete) # gets called by the caller via close()
-      wrapped = described_class.wrap(fake_body, txn)
-
-      expect { wrapped.call(fake_rack_stream) }.to raise_error(/Oopsie/)
-    end
-  end
-end