appsignal 3.9.0-java → 3.9.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87ae30cedc24d783bcd6f28bb01bb19384e0f7a280fe2c8b89585a5161aaaf77
-  data.tar.gz: 36c1760ff247804c579bb0b7bf3db2aee1d4ed53ede1a1920d5a8a1fa762f032
+  metadata.gz: d8242c596a38a842614a47cb94b88a666de659fad2b0c5270dc94747c0ec996c
+  data.tar.gz: e604b5e5acd710f2978579db85b3e274461d4c2c3b68065c9e4541b2a7f4b133
 SHA512:
-  metadata.gz: ed40403d826734ba4725b087b4d52d75be79d9bfd7172d12ceba70da3393de9bf55ca02964a81104082e9058eb44d1c3795623a21b244b13905a0310f2961d16
-  data.tar.gz: 66832484c634de15a474774f49e8c38838faf4b71889c68c4ad7ef897d1ad64c119b926152a228117409103b657f8523599597394b989bbf87553d1c072bf5a1
+  metadata.gz: 682a946ea99d3db5d552ad1c6afa1ed67493c71427dfd55172a03349f6dfdbbaaabf6459123c19598e6c66164293cd845431264e7b6d832b5cd40b870c642f67
+  data.tar.gz: ce4f0c6fdd313528c2b91ad3b0c4c50f3e05bb93b56d2f2a983da830ff4a0dfa8a1184ce6b8cad0c20091b7e1d07dedea4f259f8e528ecc86295b8ea3a375e0b

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.9.2
+
+_Published on 2024-06-26._
+
+### Added
+
+- Improve instrumentation of Hanami requests by making sure the transaction is always closed.
+  It will also report a `response_status` tag and metric for Hanami requests.
+
+  (patch [e79d4277](https://github.com/appsignal/appsignal-ruby/commit/e79d4277046bf4ec0d32263d06d4975ca8c426ee))
+
+### Changed
+
+- Instrument the entire Sinatra request. Instrumenting Sinatra apps using `require "appsignal/integrations/sinatra"` will now report more of the request, if previously other middleware were not instrumented. It will also report the response status with the `response_status` tag and metric. (patch [15b3390b](https://github.com/appsignal/appsignal-ruby/commit/15b3390b5b54cdc7378d69c92d91ec51dab1b0e4))
+
+### Fixed
+
+- Fix deprecation warnings about `Transacation.params=` usage by updating how we record parameters in our instrumentations. (patch [b65d6674](https://github.com/appsignal/appsignal-ruby/commit/b65d6674c93afbc95e9cecee8c032e6949229aab))
+- Fix error reporting for requests with an error that use the AppSignal EventHandler. (patch [0e48f19b](https://github.com/appsignal/appsignal-ruby/commit/0e48f19bb9f5c3ead96d21fbacdd5d7f221e2063))
+
+## 3.9.1
+
+_Published on 2024-06-24._
+
+### Fixed
+
+- [0a253aa1](https://github.com/appsignal/appsignal-ruby/commit/0a253aa16c00cd6172e35a4edaff34f76ac9cbe5) patch - Fix parameter reporting for Rack and Sinatra apps, especially POST payloads.
+
 ## 3.9.0
 
 _Published on 2024-06-21._

data/lib/appsignal/helpers/instrumentation.rb

@@ -176,7 +176,7 @@ module Appsignal
       #
       # @example Add more metadata to transaction
       #   Appsignal.send_error(e) do |transaction|
-      #     transaction.params = { :search_query => params[:search_query] }
+      #     transaction.set_params(:search_query => params[:search_query])
       #     transaction.set_action("my_action_name")
       #     transaction.set_tags(:key => "value")
       #     transaction.set_namespace("my_namespace")
@@ -273,7 +273,7 @@ module Appsignal
       #
       # @example Add more metadata to transaction
       #   Appsignal.set_error(e) do |transaction|
-      #     transaction.params = { :search_query => params[:search_query] }
+      #     transaction.set_params(:search_query => params[:search_query])
       #     transaction.set_action("my_action_name")
       #     transaction.set_tags(:key => "value")
       #     transaction.set_namespace("my_namespace")

data/lib/appsignal/hooks/active_job.rb

@@ -62,11 +62,12 @@ module Appsignal
             end
 
           if transaction
-            transaction.params =
+            transaction.set_params_if_nil(
               Appsignal::Utils::HashSanitizer.sanitize(
                 job["arguments"],
                 Appsignal.config[:filter_parameters]
               )
+            )
 
             transaction_tags = ActiveJobHelpers.transaction_tags_for(job)
             transaction_tags["active_job_id"] = job["job_id"]

data/lib/appsignal/integrations/action_cable.rb

@@ -22,7 +22,7 @@ module Appsignal
           transaction.set_error(exception)
           raise exception
         ensure
-          transaction.params = args.first
+          transaction.set_params_if_nil(args.first)
           transaction.set_action_if_nil("#{self.class}##{args.first["action"]}")
           transaction.set_metadata("path", request.path)
           transaction.set_metadata("method", "websocket")

data/lib/appsignal/integrations/hanami.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require "appsignal"
+require "appsignal/rack/hanami_middleware"
 
 module Appsignal
   module Integrations
+    # @api private
     module HanamiPlugin
       def self.init
         Appsignal.internal_logger.debug("Loading Hanami integration")
@@ -17,44 +19,27 @@ module Appsignal
         Appsignal.start_logger
         Appsignal.start
 
-        ::Hanami::Action.prepend Appsignal::Integrations::HanamiIntegration if Appsignal.active?
+        return unless Appsignal.active?
+
+        hanami_app_config.middleware.use(
+          ::Rack::Events,
+          [Appsignal::Rack::EventHandler.new]
+        )
+        hanami_app_config.middleware.use(Appsignal::Rack::HanamiMiddleware)
+
+        ::Hanami::Action.prepend Appsignal::Integrations::HanamiIntegration
       end
     end
-  end
-end
 
-module Appsignal::Integrations::HanamiIntegration
-  def call(env)
-    params = ::Hanami::Action::BaseParams.new(env)
-    request = ::Hanami::Action::Request.new(
-      :env => env,
-      :params => params,
-      :sessions_enabled => true
-    )
-
-    transaction = Appsignal::Transaction.create(
-      SecureRandom.uuid,
-      Appsignal::Transaction::HTTP_REQUEST,
-      request
-    )
-
-    begin
-      Appsignal.instrument("process_action.hanami") do
-        super.tap do |response|
-          transaction.set_metadata("status", response.status.to_s)
-        end
+    # @api private
+    module HanamiIntegration
+      def call(env)
+        super
+      ensure
+        transaction = env[::Appsignal::Rack::APPSIGNAL_TRANSACTION]
+
+        transaction&.set_action_if_nil(self.class.name)
       end
-    rescue Exception => error # rubocop:disable Lint/RescueException
-      transaction.set_error(error)
-      transaction.set_metadata("status", "500")
-      raise error
-    ensure
-      transaction.params = request.params.to_h
-      transaction.set_action_if_nil(self.class.name)
-      transaction.set_metadata("path", request.path)
-      transaction.set_metadata("method", request.request_method)
-      transaction.set_http_or_background_queue_start
-      Appsignal::Transaction.complete_current!
     end
   end
 end

data/lib/appsignal/integrations/railtie.rb

@@ -71,7 +71,7 @@ module Appsignal
             transaction.set_action(action_name) if action_name
             transaction.set_metadata("path", path)
             transaction.set_metadata("method", method)
-            transaction.params = params
+            transaction.set_params_if_nil(params)
             transaction.set_sample_data("custom_data", custom_data) if custom_data
 
             tags[:severity] = severity

data/lib/appsignal/integrations/resque.rb

@@ -25,7 +25,7 @@ module Appsignal
               ResqueHelpers.arguments(payload),
               Appsignal.config[:filter_parameters]
             )
-          transaction.params = args if args
+          transaction.set_params_if_nil(args)
           transaction.set_tags("queue" => queue)
 
           Appsignal::Transaction.complete_current!

data/lib/appsignal/integrations/sidekiq.rb

@@ -45,7 +45,7 @@ module Appsignal
             )
           transaction.set_action_if_nil("SidekiqInternal")
           transaction.set_metadata("sidekiq_error", sidekiq_context[:context])
-          transaction.params = { :jobstr => sidekiq_context[:jobstr] }
+          transaction.set_params_if_nil(:jobstr => sidekiq_context[:jobstr])
           transaction.set_error(exception)
         end
 
@@ -83,9 +83,7 @@ module Appsignal
         raise exception
       ensure
         if transaction
-          params = filtered_arguments(item)
-          transaction.params = params if params
-
+          transaction.set_params_if_nil(filtered_arguments(item))
           transaction.set_http_or_background_queue_start
           Appsignal::Transaction.complete_current! unless exception
 

data/lib/appsignal/integrations/sinatra.rb

@@ -16,4 +16,10 @@ unless Appsignal.active?
   Appsignal.start
 end
 
-::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation) if Appsignal.active?
+if Appsignal.active?
+  ::Sinatra::Base.use(
+    ::Rack::Events,
+    [Appsignal::Rack::EventHandler.new]
+  )
+  ::Sinatra::Base.use(Appsignal::Rack::SinatraBaseInstrumentation)
+end

data/lib/appsignal/rack/abstract_middleware.rb

@@ -91,8 +91,6 @@ module Appsignal
       # Override this method to set metadata before the app is called.
       # Call `super` to also include the default set metadata.
       def add_transaction_metadata_before(transaction, request)
-        params = params_for(request)
-        transaction.params = params if params
       end
 
       # Add metadata to the transaction based on the request environment.
@@ -104,6 +102,7 @@ module Appsignal
         transaction.set_action_if_nil(default_action)
         transaction.set_metadata("path", request.path)
         transaction.set_metadata("method", request.request_method)
+        transaction.set_params_if_nil(params_for(request))
         transaction.set_http_or_background_queue_start
       end
 

data/lib/appsignal/rack/event_handler.rb

@@ -42,22 +42,22 @@ module Appsignal
 
           request.env[RACK_AFTER_REPLY] ||= []
           request.env[RACK_AFTER_REPLY] << proc do
+            next unless event_handler.request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
+
             Appsignal::Rack::EventHandler
               .safe_execution("Appsignal::Rack::EventHandler's after_reply") do
-              next unless event_handler.request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
-
               transaction.finish_event("process_request.rack", "", "")
               transaction.set_http_or_background_queue_start
-
-              # Make sure the current transaction is always closed when the request
-              # is finished. This is a fallback for in case the `on_finish`
-              # callback is not called. This is supported by servers like Puma and
-              # Unicorn.
-              #
-              # The EventHandler.on_finish callback should be called first, this is
-              # just a fallback if that doesn't get called.
-              Appsignal::Transaction.complete_current!
             end
+
+            # Make sure the current transaction is always closed when the request
+            # is finished. This is a fallback for in case the `on_finish`
+            # callback is not called. This is supported by servers like Puma and
+            # Unicorn.
+            #
+            # The EventHandler.on_finish callback should be called first, this is
+            # just a fallback if that doesn't get called.
+            Appsignal::Transaction.complete_current!
           end
           transaction.start_event
         end
@@ -75,26 +75,28 @@ module Appsignal
       end
 
       def on_finish(request, response)
-        self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
-          return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
+        return unless request_handler?(request.env[APPSIGNAL_EVENT_HANDLER_ID])
 
-          transaction = request.env[APPSIGNAL_TRANSACTION]
-          return unless transaction
+        transaction = request.env[APPSIGNAL_TRANSACTION]
+        return unless transaction
 
+        self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
           transaction.finish_event("process_request.rack", "", "")
-          transaction.set_tags(:response_status => response.status)
           transaction.set_http_or_background_queue_start
-          Appsignal.increment_counter(
-            :response_status,
-            1,
-            :status => response.status,
-            :namespace => format_namespace(transaction.namespace)
-          )
-
-          # Make sure the current transaction is always closed when the request
-          # is finished
-          Appsignal::Transaction.complete_current!
+          if response
+            transaction.set_tags(:response_status => response.status)
+            Appsignal.increment_counter(
+              :response_status,
+              1,
+              :status => response.status,
+              :namespace => format_namespace(transaction.namespace)
+            )
+          end
         end
+
+        # Make sure the current transaction is always closed when the request
+        # is finished
+        Appsignal::Transaction.complete_current!
       end
 
       private

data/lib/appsignal/rack/hanami_middleware.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Rack
+    # @api private
+    class HanamiMiddleware < AbstractMiddleware
+      def initialize(app, options = {})
+        options[:request_class] ||= ::Hanami::Action::Request
+        options[:params_method] ||= :params
+        options[:instrument_span_name] ||= "process_action.hanami"
+        super
+      end
+
+      private
+
+      def params_for(request)
+        super&.to_h
+      end
+
+      def request_for(env)
+        params = ::Hanami::Action.params_class.new(env)
+        @request_class.new(
+          :env => env,
+          :params => params,
+          :sessions_enabled => true
+        )
+      end
+    end
+  end
+end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -28,8 +28,6 @@ module Appsignal
         )
 
         begin
-          transaction.params = fetch_params(request)
-
           @app.call(env)
         rescue Exception => error # rubocop:disable Lint/RescueException
           transaction.set_error(error)
@@ -39,6 +37,7 @@ module Appsignal
           if controller
             transaction.set_action_if_nil("#{controller.class}##{controller.action_name}")
           end
+          transaction.set_params_if_nil(fetch_params(request))
           request_id = fetch_request_id(env)
           transaction.set_tags(:request_id => request_id) if request_id
           transaction.set_metadata("path", request.path)

data/lib/appsignal/transaction.rb

@@ -76,18 +76,6 @@ module Appsignal
     attr_reader :ext, :transaction_id, :action, :namespace, :request, :paused, :tags, :options,
       :discarded, :breadcrumbs
 
-    # @!attribute params
-    #   Attribute for parameters of the transaction.
-    #
-    #   When no parameters are set with {#params=} the parameters it will look
-    #   for parameters on the {#request} environment.
-    #
-    #   The parameters set using {#params=} are leading over those extracted
-    #   from a request's environment.
-    #
-    #   @return [Hash]
-    attr_writer :params
-
     def initialize(transaction_id, namespace, request, options = {})
       @transaction_id = transaction_id
       @action = nil
@@ -156,6 +144,40 @@ module Appsignal
       request_params
     end
 
+    # Set parameters on the transaction.
+    #
+    # When no parameters are set this way, the transaction will look for
+    # parameters on the {#request} environment.
+    #
+    # The parameters set using {#set_params} are leading over those extracted
+    # from a request's environment.
+    #
+    # @param given_params [Hash] The parameters to set on the transaction.
+    # @return [void]
+    def set_params(given_params)
+      @params = given_params if given_params
+    end
+
+    # @deprecated Use {#set_params} or {#set_params_if_nil} instead.
+    def params=(given_params)
+      Appsignal::Utils::StdoutAndLoggerMessage.warning(
+        "Transaction#params= is deprecated." \
+          "Use Transaction#set_params or #set_params_if_nil instead."
+      )
+      set_params(given_params)
+    end
+
+    # Set parameters on the transaction if not already set
+    #
+    # When no parameters are set this way, the transaction will look for
+    # parameters on the {#request} environment.
+    #
+    # @param given_params [Hash] The parameters to set on the transaction if none are already set.
+    # @return [void]
+    def set_params_if_nil(given_params)
+      set_params(given_params) unless @params
+    end
+
     # Set tags on the transaction.
     #
     # @param given_tags [Hash] Collection of tags.

data/lib/appsignal/version.rb

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

data/spec/lib/appsignal/integrations/hanami_spec.rb

@@ -5,32 +5,62 @@ if DependencyHelper.hanami2_present?
     require "appsignal/integrations/hanami"
 
     before do
-      allow(Appsignal).to receive(:active?).and_return(true)
-      allow(Appsignal).to receive(:start).and_return(true)
-      allow(Appsignal).to receive(:start_logger).and_return(true)
+      uninstall_hanami_middleware
+    end
+
+    def uninstall_hanami_middleware
+      middleware_stack = ::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX]
+      middleware_stack.delete_if do |middleware|
+        middleware.first == Appsignal::Rack::HanamiMiddleware ||
+          middleware.first == Rack::Events
+      end
     end
 
     describe Appsignal::Integrations::HanamiPlugin do
       it "starts AppSignal on init" do
         expect(Appsignal).to receive(:start)
+        expect(Appsignal).to receive(:start_logger)
+        Appsignal::Integrations::HanamiPlugin.init
       end
 
-      it "starts the logger on init" do
-        expect(Appsignal).to receive(:start_logger)
+      it "prepends the integration to Hanami::Action" do
+        allow(Appsignal).to receive(:active?).and_return(true)
+        Appsignal::Integrations::HanamiPlugin.init
+        expect(::Hanami::Action.included_modules)
+          .to include(Appsignal::Integrations::HanamiIntegration)
       end
 
-      it "prepends the integration to Hanami" do
-        expect(::Hanami::Action).to receive(:prepend)
-          .with(Appsignal::Integrations::HanamiIntegration)
+      it "adds middleware to the Hanami app" do
+        allow(Appsignal).to receive(:active?).and_return(true)
+        Appsignal::Integrations::HanamiPlugin.init
+
+        expect(::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX])
+          .to include(
+            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], nil],
+            [Appsignal::Rack::HanamiMiddleware, [], nil]
+          )
       end
 
       context "when not active" do
         before { allow(Appsignal).to receive(:active?).and_return(false) }
 
-        it "does not prepend the integration" do
+        it "does not prepend the integration to Hanami::Action" do
+          Appsignal::Integrations::HanamiPlugin.init
           expect(::Hanami::Action).to_not receive(:prepend)
             .with(Appsignal::Integrations::HanamiIntegration)
         end
+
+        it "does not add the middleware to the Hanami app" do
+          Appsignal::Integrations::HanamiPlugin.init
+
+          middleware_stack = ::Hanami.app.config.middleware.stack[::Hanami::Router::DEFAULT_PREFIX]
+          expect(middleware_stack).to_not include(
+            [Rack::Events, [[kind_of(Appsignal::Rack::EventHandler)]], nil]
+          )
+          expect(middleware_stack).to_not include(
+            [Appsignal::Rack::HanamiMiddleware, [], nil]
+          )
+        end
       end
 
       context "when APPSIGNAL_APP_ENV ENV var is provided" do
@@ -52,71 +82,45 @@ if DependencyHelper.hanami2_present?
           expect(Appsignal.config.env).to eq("test")
         end
       end
-
-      after { Appsignal::Integrations::HanamiPlugin.init }
     end
 
-    describe "Hanami Actions" do
-      let(:env) do
-        Rack::MockRequest.env_for(
-          "/books",
-          "router.params" => router_params,
-          :method => "GET"
-        )
+    describe Appsignal::Integrations::HanamiIntegration do
+      let(:transaction) { http_request_transaction }
+      around { |example| keep_transactions { example.run } }
+      before(:context) { start_agent }
+      before do
+        allow(Appsignal).to receive(:active?).and_return(true)
+        Appsignal::Integrations::HanamiPlugin.init
       end
 
-      let(:router_params) { { :foo => "bar", :baz => "qux" } }
-
-      describe "#call", :error => false do
-        it "sets params" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:params=).with(router_params)
-        end
-
-        it "sets the action name" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_action_if_nil)
-            .with("HanamiApp::Actions::Books::Index")
-        end
-
-        it "sets the metadata" do
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
-            .with("status", "200")
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
-            .with("path", "/books")
-          expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
-            .with("method", "GET")
-        end
+      def make_request(env, app: HanamiApp::Actions::Books::Index)
+        action = app.new
+        action.call(env)
+      end
 
-        it "sets the queue start" do
-          expect_any_instance_of(Appsignal::Transaction)
-            .to receive(:set_http_or_background_queue_start)
-        end
+      describe "#call" do
+        context "without an active transaction" do
+          let(:env) { {} }
 
-        context "with error", :error => true do
-          let(:error) { HanamiApp::ExampleError }
+          it "does not set the action name" do
+            make_request(env)
 
-          it "records the exception" do
-            expect_any_instance_of(Appsignal::Transaction).to receive(:set_error).with(error)
-          end
-
-          it "sets the status to 500" do
-            expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata)
-              .with("status", "500")
-            expect_any_instance_of(Appsignal::Transaction).to receive(:set_metadata).twice
+            expect(transaction.to_h).to include(
+              "action" => nil
+            )
           end
         end
 
-        after(:error => false) do
-          Appsignal::Integrations::HanamiPlugin.init
-
-          action = HanamiApp::Actions::Books::Index.new
-          action.call(env)
-        end
+        context "with an active transaction" do
+          let(:env) { { Appsignal::Rack::APPSIGNAL_TRANSACTION => transaction } }
 
-        after(:error => true) do
-          Appsignal::Integrations::HanamiPlugin.init
+          it "sets action name on the transaction" do
+            make_request(env)
 
-          action = HanamiApp::Actions::Books::Error.new
-          expect { action.call(env) }.to raise_error(error)
+            expect(transaction.to_h).to include(
+              "action" => "HanamiApp::Actions::Books::Index"
+            )
+          end
         end
       end
     end

data/spec/lib/appsignal/integrations/sinatra_spec.rb

@@ -50,9 +50,13 @@ if DependencyHelper.sinatra_present?
         context "when AppSignal is not active" do
           it "does not add the instrumentation middleware to Sinatra::Base" do
             install_sinatra_integration
-            expect(Sinatra::Base.middleware.to_a).to_not include(
+            middlewares = Sinatra::Base.middleware.to_a
+            expect(middlewares).to_not include(
               [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
             )
+            expect(middlewares).to_not include(
+              [Rack::Events, [Appsignal::Rack::EventHandler], nil]
+            )
           end
         end
 
@@ -63,7 +67,9 @@ if DependencyHelper.sinatra_present?
             ENV["APPSIGNAL_PUSH_API_KEY"] = "my-key"
 
             install_sinatra_integration
-            expect(Sinatra::Base.middleware.to_a).to include(
+            middlewares = Sinatra::Base.middleware.to_a
+            expect(middlewares).to include(
+              [Rack::Events, [[Appsignal::Rack::EventHandler]], nil],
               [Appsignal::Rack::SinatraBaseInstrumentation, [], nil]
             )
           end

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

@@ -66,6 +66,30 @@ describe Appsignal::Rack::EventHandler do
       expect(last_transaction.ext.queue_start).to eq(queue_start_time)
     end
 
+    context "with error inside rack.after_reply handler" do
+      before do
+        on_start
+        # A random spot we can access to raise an error for this test
+        expect(request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION])
+          .to receive(:finish_event)
+          .and_raise(ExampleStandardError, "oh no")
+        callback = request.env[Appsignal::Rack::RACK_AFTER_REPLY].first
+        callback.call
+      end
+
+      it "completes the transaction" do
+        expect(last_transaction).to be_completed
+      end
+
+      it "logs an error" do
+        expect(log).to contains_log(
+          :error,
+          "Error occurred in Appsignal::Rack::EventHandler's after_reply: " \
+            "ExampleStandardError: oh no"
+        )
+      end
+    end
+
     it "logs errors from rack.after_reply callbacks" do
       on_start
 
@@ -139,8 +163,8 @@ describe Appsignal::Rack::EventHandler do
   describe "#on_finish" do
     let(:response) { Rack::Events::BufferedResponse.new(200, {}, ["body"]) }
 
-    def on_finish
-      event_handler_instance.on_finish(request, response)
+    def on_finish(given_request = request, given_response = response)
+      event_handler_instance.on_finish(given_request, given_response)
     end
 
     it "doesn't do anything without a transaction" do
@@ -155,6 +179,7 @@ describe Appsignal::Rack::EventHandler do
         "sample_data" => {},
         "events" => []
       )
+      expect(last_transaction).to_not be_completed
     end
 
     it "completes the transaction" do
@@ -176,6 +201,60 @@ describe Appsignal::Rack::EventHandler do
       expect(last_transaction).to be_completed
     end
 
+    context "without a response" do
+      it "completes the transaction" do
+        on_start
+        on_finish(request, nil)
+
+        expect(last_transaction.to_h).to include(
+          # The action is not set on purpose, as we can't set a normalized route
+          # It requires the app to set an action name
+          "action" => nil,
+          "sample_data" => hash_including(
+            "environment" => {
+              "REQUEST_METHOD" => "GET",
+              "PATH_INFO" => "/path"
+            }
+          )
+        )
+        expect(last_transaction.ext.queue_start).to eq(queue_start_time)
+        expect(last_transaction).to be_completed
+      end
+
+      it "does not set a response_status tag" do
+        on_start
+        on_finish(request, nil)
+
+        expect(last_transaction.to_h.dig("sample_data", "tags")).to_not have_key("response_status")
+      end
+
+      it "does not report a response_status counter metric" do
+        expect(Appsignal).to_not receive(:increment_counter)
+          .with(:response_status, anything, anything)
+
+        on_start
+        on_finish(request, nil)
+      end
+    end
+
+    context "with error inside on_finish handler" do
+      before do
+        on_start
+        # A random spot we can access to raise an error for this test
+        expect(Appsignal).to receive(:increment_counter).and_raise(ExampleStandardError, "oh no")
+        on_finish
+      end
+
+      it "completes the transaction" do
+        expect(last_transaction).to be_completed
+      end
+
+      it "logs an error" do
+        expect(log).to contains_log(:error,
+          "Error occurred in Appsignal::Rack::EventHandler#on_finish: ExampleStandardError: oh no")
+      end
+    end
+
     context "when the handler is nested in another EventHandler" do
       it "does not complete the transaction" do
         on_start
@@ -237,8 +316,8 @@ describe Appsignal::Rack::EventHandler do
     end
 
     it "logs an error in case of an error" do
-      expect(Appsignal::Transaction)
-        .to receive(:complete_current!).and_raise(ExampleStandardError, "oh no")
+      # A random spot we can access to raise an error for this test
+      expect(Appsignal).to receive(:increment_counter).and_raise(ExampleStandardError, "oh no")
 
       on_start
       on_finish

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

@@ -0,0 +1,50 @@
+require "appsignal/rack/hanami_middleware"
+
+if DependencyHelper.hanami2_present?
+  describe Appsignal::Rack::HanamiMiddleware do
+    let(:app) { double(:call => true) }
+    let(:router_params) { { "param1" => "value1", "param2" => "value2" } }
+    let(:env) do
+      Rack::MockRequest.env_for(
+        "/some/path",
+        "router.params" => router_params
+      )
+    end
+    let(:middleware) { Appsignal::Rack::HanamiMiddleware.new(app, {}) }
+
+    before(:context) { start_agent }
+    around { |example| keep_transactions { example.run } }
+
+    def make_request(env)
+      middleware.call(env)
+    end
+
+    context "with params" do
+      it "sets request parameters on the transaction" do
+        make_request(env)
+
+        expect(last_transaction.to_h).to include(
+          "sample_data" => hash_including(
+            "params" => { "param1" => "value1", "param2" => "value2" }
+          )
+        )
+      end
+    end
+
+    it "reports a process_action.hanami event" do
+      make_request(env)
+
+      expect(last_transaction.to_h).to include(
+        "events" => [
+          hash_including(
+            "body" => "",
+            "body_format" => Appsignal::EventFormatter::DEFAULT,
+            "count" => 1,
+            "name" => "process_action.hanami",
+            "title" => ""
+          )
+        ]
+      )
+    end
+  end
+end

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

@@ -115,7 +115,7 @@ if DependencyHelper.rails_present?
       context "with custom params" do
         let(:app) do
           lambda do |env|
-            env[Appsignal::Rack::APPSIGNAL_TRANSACTION].params = { "custom_param" => "yes" }
+            env[Appsignal::Rack::APPSIGNAL_TRANSACTION].set_params("custom_param" => "yes")
           end
         end
 

data/spec/lib/appsignal/transaction_spec.rb

@@ -328,7 +328,7 @@ describe Appsignal::Transaction do
 
       context "with custom params set on transaction" do
         before do
-          transaction.params = { :foo => "bar" }
+          transaction.set_params(:foo => "bar")
         end
 
         it "returns custom parameters" do
@@ -348,9 +348,92 @@ describe Appsignal::Transaction do
     end
 
     describe "#params=" do
+      around { |example| keep_transactions { example.run } }
+
       it "sets params on the transaction" do
-        transaction.params = { :foo => "bar" }
-        expect(transaction.params).to eq(:foo => "bar")
+        params = { "foo" => "bar" }
+        silence { transaction.params = params }
+
+        transaction.complete # Sample the data
+        expect(transaction.params).to eq(params)
+        expect(transaction.to_h.dig("sample_data", "params")).to eq(params)
+      end
+
+      it "logs a deprecation warning" do
+        transaction.params = { "foo" => "bar" }
+
+        expect(log_contents(log)).to contains_log(
+          :warn,
+          "Transaction#params= is deprecated." \
+            "Use Transaction#set_params or #set_params_if_nil instead."
+        )
+      end
+    end
+
+    describe "#set_params" do
+      around { |example| keep_transactions { example.run } }
+
+      context "when the params are set" do
+        it "updates the params on the transaction" do
+          params = { "key" => "value" }
+          transaction.set_params(params)
+
+          transaction.complete # Sample the data
+          expect(transaction.params).to eq(params)
+          expect(transaction.to_h.dig("sample_data", "params")).to eq(params)
+        end
+      end
+
+      context "when the given params is nil" do
+        it "does not update the params on the transaction" do
+          params = { "key" => "value" }
+          transaction.set_params(params)
+          transaction.set_params(nil)
+
+          transaction.complete # Sample the data
+          expect(transaction.params).to eq(params)
+          expect(transaction.to_h.dig("sample_data", "params")).to eq(params)
+        end
+      end
+    end
+
+    describe "#set_params_if_nil" do
+      around { |example| keep_transactions { example.run } }
+
+      context "when the params are not set" do
+        it "sets the params on the transaction" do
+          params = { "key" => "value" }
+          transaction.set_params_if_nil(params)
+
+          transaction.complete # Sample the data
+          expect(transaction.params).to eq(params)
+          expect(transaction.to_h.dig("sample_data", "params")).to eq(params)
+        end
+
+        context "when the given params is nil" do
+          it "does not update the params on the transaction" do
+            params = { "key" => "value" }
+            transaction.set_params(params)
+            transaction.set_params_if_nil(nil)
+
+            transaction.complete # Sample the data
+            expect(transaction.params).to eq(params)
+            expect(transaction.to_h.dig("sample_data", "params")).to eq(params)
+          end
+        end
+      end
+
+      context "when the params are set" do
+        it "does not update the params on the transaction" do
+          preset_params = { "other" => "params" }
+          params = { "key" => "value" }
+          transaction.set_params(preset_params)
+          transaction.set_params_if_nil(params)
+
+          transaction.complete # Sample the data
+          expect(transaction.params).to eq(preset_params)
+          expect(transaction.to_h.dig("sample_data", "params")).to eq(preset_params)
+        end
       end
     end
 
@@ -1158,7 +1241,7 @@ describe Appsignal::Transaction do
 
       context "with custom params" do
         before do
-          transaction.params = { :foo => "bar", :baz => :bat }
+          transaction.set_params(:foo => "bar", :baz => :bat)
         end
 
         it "returns custom params" do

data/spec/support/hanami/hanami_app.rb

@@ -21,11 +21,9 @@ module HanamiApp
 
       class Error < Hanami::Action
         def handle(_request, _response)
-          raise ExampleError
+          raise ExampleException, "exception message"
         end
       end
     end
   end
-
-  class ExampleError < StandardError; end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.9.0
+  version: 3.9.2
 platform: java
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-21 00:00:00.000000000 Z
+date: 2024-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -288,6 +288,7 @@ files:
 - lib/appsignal/rack/abstract_middleware.rb
 - lib/appsignal/rack/event_handler.rb
 - lib/appsignal/rack/generic_instrumentation.rb
+- lib/appsignal/rack/hanami_middleware.rb
 - lib/appsignal/rack/rails_instrumentation.rb
 - lib/appsignal/rack/sinatra_instrumentation.rb
 - lib/appsignal/rack/streaming_listener.rb
@@ -390,6 +391,7 @@ files:
 - spec/lib/appsignal/rack/abstract_middleware_spec.rb
 - spec/lib/appsignal/rack/event_handler_spec.rb
 - spec/lib/appsignal/rack/generic_instrumentation_spec.rb
+- spec/lib/appsignal/rack/hanami_middleware_spec.rb
 - spec/lib/appsignal/rack/rails_instrumentation_spec.rb
 - spec/lib/appsignal/rack/sinatra_instrumentation_spec.rb
 - spec/lib/appsignal/rack/streaming_listener_spec.rb