appsignal 3.7.6 → 3.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2efeb1057d0b9afac2d97367e7cc531c5ae0b5781da74d612ac8f1d27b3c1441
-  data.tar.gz: e55719783fdaad7abd0cf6fcdee6a27206e9b1f08ed0ef5ac577422e9258d5d4
+  metadata.gz: f68ce83624657d12b65c203950c7a92681d621bc9f5644fcc61d4123417e8e93
+  data.tar.gz: ecda706a29b6aea7d52d3620cebb984495c85937acf561a596826fd57c457095
 SHA512:
-  metadata.gz: 3cc5ce97c7050bad66f043c92fee70c7e1ad215aa8eec8cf72ddff2edd0a34f875fe3fb63794d010f534eba32a8c15c12f81b6b0f03c61a62b9fd6e48562aed0
-  data.tar.gz: a6a3da8e140002a3bb41b3135d4e23727aa77b21c33f533e926ea71b7d9fe96268e6a845837a0555a18e06eb7b443204c1814a6558a2622ef1efd38ed707458f
+  metadata.gz: 9ec9d7754da4808d85efd335d8e9c00bca8f0e2c16f7a4a9246b9bd9d679519c7550202c1d2f809c786e117cde31c76c8c3405664b9878b9b8c61724a05dca14
+  data.tar.gz: 955a45291f05e0df7456ae7bef0c7d9be55824b764429a6fffd72985ee252dcf83893e824a610d086c82c0050ae14bb6ddebc6baaf600946c1d50ce55a3ae4d7

data/.github/workflows/create_release_from_tag.yml

@@ -15,6 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     env:
       PACKAGE_NAME: "Ruby gem"
+      CHANGELOG_CATEGORY: "Ruby"
       CHANGELOG_LINK: "https://github.com/appsignal/appsignal-ruby/blob/main/CHANGELOG.md"
     steps:
       - name: Checkout repository at tag
@@ -46,10 +47,12 @@ jobs:
         run: |
           # Prepare JSON payload using jq to ensure proper escaping
           payload=$(jq -n \
-            --arg package "Ruby gem" \
-            --arg version "${{ env.TAG_NAME }}" \
+            --arg title "$PACKAGE_NAME ${{ env.TAG_NAME }}" \
+            --arg category "$CHANGELOG_CATEGORY" \
+            --arg version "$(echo "${{ env.TAG_NAME }}" | sed 's/^v//')" \
             --arg changelog "$(cat CHANGELOG_TEXT.txt)" \
-            '{ref: "main", inputs: {package: $package, version: $version, changelog: $changelog}}')
+            --arg assignee "${{ github.actor }}" \
+            '{ref: "main", inputs: {title: $title, category: $category, version: $version, changelog: $changelog, assignee: $assignee}}')
 
           curl -X POST \
             -H "Authorization: token ${{ secrets.INTEGRATIONS_CHANGELOG_TOKEN }}" \

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # AppSignal for Ruby gem Changelog
 
+## 3.8.1
+
+_Published on 2024-06-17._
+
+### Added
+
+- [5459a021](https://github.com/appsignal/appsignal-ruby/commit/5459a021d7d4bbbd09a0dcbdf5f3af7bf861b6f5) patch - Report the response status for Rails requests as the `response_status` tag on samples, e.g. 200, 301, 500. This tag is visible on the sample detail page.
+  
+  The response status is also reported as the `response_status` metric.
+
+## 3.8.0
+
+_Published on 2024-06-17._
+
+### Changed
+
+- [ca53b043](https://github.com/appsignal/appsignal-ruby/commit/ca53b04360ae123498640d043ee7ba74efc4b295) minor - Report the time spent in Rails middleware as part of the request duration. The AppSignal Rack middleware is now higher in the middleware stack and reports more time of the request to give insights in how long other middleware took. This is reported under the new `process_request.rack` event in the event timeline.
+
+### Fixed
+
+- [37fbae5a](https://github.com/appsignal/appsignal-ruby/commit/37fbae5a0f1a4e964baceb21837e5d5f0cf903c0) patch - Fix ArgumentError being raised on Ruby logger and Rails.logger error calls. This fixes the error from being raised from within the AppSignal Ruby gem.
+  Please do not use this for error reporting. We recommend using our error reporting feature instead to be notified of new errors. Read more on [exception handling in Ruby with our Ruby gem](https://docs.appsignal.com/ruby/instrumentation/exception-handling.html).
+  
+  ```ruby
+  # No longer raises an error
+  Rails.logger.error StandardError.new("StandardError log message")
+  ```
+
 ## 3.7.6
 
 _Published on 2024-06-11._

data/lib/appsignal/integrations/railtie.rb

@@ -29,6 +29,11 @@ module Appsignal
         # Start logger
         Appsignal.start_logger
 
+        app.middleware.insert(
+          0,
+          ::Rack::Events,
+          [Appsignal::Rack::EventHandler.new]
+        )
         app.middleware.insert_after(
           ActionDispatch::DebugExceptions,
           Appsignal::Rack::RailsInstrumentation

data/lib/appsignal/logger.rb

@@ -53,6 +53,13 @@ module Appsignal
 
       message = formatter.call(severity, Time.now, group, message) if formatter
 
+      unless message.is_a?(String)
+        Appsignal.internal_logger.warn(
+          "Logger message was ignored, because it was not a String: #{message.inspect}"
+        )
+        return
+      end
+
       Appsignal::Extension.log(
         group,
         SEVERITY_MAP.fetch(severity, 0),
@@ -112,6 +119,8 @@ module Appsignal
       message = yield if message.nil? && block_given?
       return if message.nil?
 
+      message = "#{message.class}: #{message.message}" if message.is_a?(Exception)
+
       add_with_attributes(ERROR, message, @group, attributes)
     end
 

data/lib/appsignal/rack/event_handler.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Appsignal
+  module Rack
+    APPSIGNAL_TRANSACTION = "appsignal.transaction"
+    RACK_AFTER_REPLY = "rack.after_reply"
+
+    class EventHandler
+      include ::Rack::Events::Abstract
+
+      def self.safe_execution(name)
+        yield
+      rescue => e
+        Appsignal.internal_logger.error(
+          "Error occurred in #{name}: #{e.class}: #{e}: #{e.backtrace}"
+        )
+      end
+
+      def on_start(request, _response)
+        self.class.safe_execution("Appsignal::Rack::EventHandler#on_start") do
+          transaction = Appsignal::Transaction.create(
+            SecureRandom.uuid,
+            Appsignal::Transaction::HTTP_REQUEST,
+            request
+          )
+          request.env[APPSIGNAL_TRANSACTION] = transaction
+
+          request.env[RACK_AFTER_REPLY] ||= []
+          request.env[RACK_AFTER_REPLY] << proc do
+            Appsignal::Rack::EventHandler
+              .safe_execution("Appsignal::Rack::EventHandler's after_reply") do
+              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
+          end
+          transaction.start_event
+        end
+      end
+
+      def on_error(request, _response, error)
+        self.class.safe_execution("Appsignal::Rack::EventHandler#on_error") do
+          transaction = request.env[APPSIGNAL_TRANSACTION]
+          return unless transaction
+
+          transaction.set_error(error)
+        end
+      end
+
+      def on_finish(request, response)
+        self.class.safe_execution("Appsignal::Rack::EventHandler#on_finish") do
+          transaction = request.env[APPSIGNAL_TRANSACTION]
+          return unless transaction
+
+          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!
+        end
+      end
+
+      private
+
+      def format_namespace(namespace)
+        if namespace == Appsignal::Transaction::HTTP_REQUEST
+          :web
+        else
+          namespace
+        end
+      end
+    end
+  end
+end

data/lib/appsignal/rack/rails_instrumentation.rb

@@ -22,13 +22,14 @@ module Appsignal
 
       def call_with_appsignal_monitoring(env)
         request = ActionDispatch::Request.new(env)
-        transaction = Appsignal::Transaction.create(
-          request_id(env),
-          Appsignal::Transaction::HTTP_REQUEST,
-          request,
-          :params_method => :filtered_parameters
+        transaction = env.fetch(
+          Appsignal::Rack::APPSIGNAL_TRANSACTION,
+          Appsignal::Transaction::NilTransaction.new
         )
+
         begin
+          transaction.params = fetch_params(request)
+
           @app.call(env)
         rescue Exception => error # rubocop:disable Lint/RescueException
           transaction.set_error(error)
@@ -38,19 +39,33 @@ module Appsignal
           if controller
             transaction.set_action_if_nil("#{controller.class}##{controller.action_name}")
           end
-          transaction.set_http_or_background_queue_start
+          request_id = fetch_request_id(env)
+          transaction.set_tags(:request_id => request_id) if request_id
           transaction.set_metadata("path", request.path)
-          begin
-            transaction.set_metadata("method", request.request_method)
-          rescue => error
-            Appsignal.internal_logger.error("Unable to report HTTP request method: '#{error}'")
-          end
-          Appsignal::Transaction.complete_current!
+          request_method = fetch_request_method(request)
+          transaction.set_metadata("method", request_method) if request_method
         end
       end
 
-      def request_id(env)
-        env["action_dispatch.request_id"] || SecureRandom.uuid
+      def fetch_request_id(env)
+        env["action_dispatch.request_id"]
+      end
+
+      def fetch_params(request)
+        return unless request.respond_to?(:filtered_parameters)
+
+        request.filtered_parameters
+      rescue => error
+        # Getting params from the request has been know to fail.
+        Appsignal.internal_logger.debug "Exception while getting Rails params: #{error}"
+        nil
+      end
+
+      def fetch_request_method(request)
+        request.request_method
+      rescue => error
+        Appsignal.internal_logger.error("Unable to report HTTP request method: '#{error}'")
+        nil
       end
     end
   end

data/lib/appsignal/version.rb

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

data/lib/appsignal.rb

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

data/spec/lib/appsignal/logger_spec.rb

@@ -1,6 +1,12 @@
 describe Appsignal::Logger do
+  let(:log_stream) { StringIO.new }
+  let(:logs) { log_contents(log_stream) }
   let(:logger) { Appsignal::Logger.new("group", :level => ::Logger::DEBUG) }
 
+  before do
+    Appsignal.internal_logger = test_logger(log_stream)
+  end
+
   it "should not create a logger with a nil group" do
     expect do
       Appsignal::Logger.new(nil)
@@ -14,6 +20,19 @@ describe Appsignal::Logger do
       logger.add(::Logger::INFO, "Log message")
     end
 
+    it "does not log a message that's not a String" do
+      expect(Appsignal::Extension).to_not receive(:log)
+      logger.add(::Logger::INFO, 123)
+      logger.add(::Logger::INFO, {})
+      logger.add(::Logger::INFO, [])
+      expect(logs)
+        .to contains_log(:warn, "Logger message was ignored, because it was not a String: 123")
+      expect(logs)
+        .to contains_log(:warn, "Logger message was ignored, because it was not a String: []")
+      expect(logs)
+        .to contains_log(:warn, "Logger message was ignored, because it was not a String: {}")
+    end
+
     it "should log with a block" do
       expect(Appsignal::Extension).to receive(:log)
         .with("group", 3, 0, "Log message", instance_of(Appsignal::Extension::Data))
@@ -162,4 +181,25 @@ describe Appsignal::Logger do
       end
     end
   end
+
+  describe "#error with exception object" do
+    it "logs the exception class and its message" do
+      error =
+        begin
+          raise ExampleStandardError, "oh no!"
+        rescue => e
+          # This makes the exception include a backtrace, so we can assert it's NOT included
+          e
+        end
+      expect(Appsignal::Extension).to receive(:log)
+        .with(
+          "group",
+          6,
+          0,
+          "ExampleStandardError: oh no!",
+          instance_of(Appsignal::Extension::Data)
+        )
+      logger.error(error)
+    end
+  end
 end

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

@@ -0,0 +1,218 @@
+describe Appsignal::Rack::EventHandler do
+  let(:queue_start_time) { fixed_time * 1_000 }
+  let(:env) do
+    {
+      "HTTP_X_REQUEST_START" => "t=#{queue_start_time.to_i}", # in milliseconds
+      "REQUEST_METHOD" => "GET",
+      "PATH_INFO" => "/path"
+    }
+  end
+  let(:request) { Rack::Request.new(env) }
+  let(:response) { nil }
+  let(:log_stream) { StringIO.new }
+  let(:log) { log_contents(log_stream) }
+  before do
+    start_agent
+    Appsignal.internal_logger = test_logger(log_stream)
+  end
+  around { |example| keep_transactions { example.run } }
+
+  def on_start
+    described_class.new.on_start(request, response)
+  end
+
+  describe "#on_start" do
+    it "creates a new transaction" do
+      expect { on_start }.to change { created_transactions.length }.by(1)
+
+      transaction = last_transaction
+      expect(transaction.to_h).to include(
+        "id" => kind_of(String),
+        "namespace" => Appsignal::Transaction::HTTP_REQUEST
+      )
+
+      expect(Appsignal::Transaction.current).to eq(last_transaction)
+    end
+
+    it "registers transaction on the request environment" do
+      on_start
+
+      expect(request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION])
+        .to eq(last_transaction)
+    end
+
+    it "registers an rack.after_reply callback that completes the transaction" do
+      request.env[Appsignal::Rack::RACK_AFTER_REPLY] = []
+      expect do
+        on_start
+      end.to change { request.env[Appsignal::Rack::RACK_AFTER_REPLY].length }.by(1)
+
+      expect(Appsignal::Transaction.current).to eq(last_transaction)
+
+      callback = request.env[Appsignal::Rack::RACK_AFTER_REPLY].first
+      callback.call
+
+      expect(Appsignal::Transaction.current).to be_kind_of(Appsignal::Transaction::NilTransaction)
+
+      expect(last_transaction.ext.queue_start).to eq(queue_start_time)
+    end
+
+    it "logs errors from rack.after_reply callbacks" do
+      on_start
+
+      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
+
+      expect(log).to contains_log(
+        :error,
+        "Error occurred in Appsignal::Rack::EventHandler's after_reply: ExampleStandardError: oh no"
+      )
+    end
+
+    it "logs an error in case of an error" do
+      expect(Appsignal::Transaction)
+        .to receive(:create).and_raise(ExampleStandardError, "oh no")
+
+      on_start
+
+      expect(log).to contains_log(
+        :error,
+        "Error occurred in Appsignal::Rack::EventHandler#on_start: ExampleStandardError: oh no"
+      )
+    end
+  end
+
+  describe "#on_error" do
+    def on_error(error)
+      described_class.new.on_error(request, response, error)
+    end
+
+    it "reports the error" do
+      on_start
+      on_error(ExampleStandardError.new("the error"))
+
+      expect(last_transaction.to_h).to include(
+        "error" => {
+          "name" => "ExampleStandardError",
+          "message" => "the error",
+          "backtrace" => kind_of(String)
+        }
+      )
+    end
+
+    it "logs an error in case of an internal error" do
+      on_start
+
+      expect(request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION])
+        .to receive(:set_error).and_raise(ExampleStandardError, "oh no")
+
+      on_error(ExampleStandardError.new("the error"))
+
+      expect(log).to contains_log(
+        :error,
+        "Error occurred in Appsignal::Rack::EventHandler#on_error: ExampleStandardError: oh no"
+      )
+    end
+  end
+
+  describe "#on_finish" do
+    let(:response) { Rack::Events::BufferedResponse.new(200, {}, ["body"]) }
+
+    def on_finish
+      described_class.new.on_finish(request, response)
+    end
+
+    it "doesn't do anything without a transaction" do
+      on_start
+
+      request.env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = nil
+
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        "action" => nil,
+        "sample_data" => {},
+        "events" => []
+      )
+    end
+
+    it "completes the transaction" do
+      on_start
+      on_finish
+
+      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)
+    end
+
+    it "doesn't set the action name if already set" do
+      on_start
+      last_transaction.set_action("My action")
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        "action" => "My action"
+      )
+    end
+
+    it "finishes the process_request.rack event" do
+      on_start
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        "events" => [
+          hash_including(
+            "name" => "process_request.rack",
+            "title" => "",
+            "body" => "",
+            "body_format" => Appsignal::EventFormatter::DEFAULT
+          )
+        ]
+      )
+    end
+
+    it "sets the response status as a tag" do
+      on_start
+      on_finish
+
+      expect(last_transaction.to_h).to include(
+        "sample_data" => hash_including(
+          "tags" => { "response_status" => 200 }
+        )
+      )
+    end
+
+    it "increments the response status counter for response status" do
+      expect(Appsignal).to receive(:increment_counter)
+        .with(:response_status, 1, :status => 200, :namespace => :web)
+
+      on_start
+      on_finish
+    end
+
+    it "logs an error in case of an error" do
+      expect(Appsignal::Transaction)
+        .to receive(:complete_current!).and_raise(ExampleStandardError, "oh no")
+
+      on_start
+      on_finish
+
+      expect(log).to contains_log(
+        :error,
+        "Error occurred in Appsignal::Rack::EventHandler#on_finish: ExampleStandardError: oh no"
+      )
+    end
+  end
+end

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

@@ -1,14 +1,21 @@
 if DependencyHelper.rails_present?
-  class MockController
-  end
-
   describe Appsignal::Rack::RailsInstrumentation do
+    class MockController; end
+
     let(:log) { StringIO.new }
     before do
       start_agent
       Appsignal.internal_logger = test_logger(log)
     end
 
+    let(:transaction) do
+      Appsignal::Transaction.new(
+        "transaction_id",
+        Appsignal::Transaction::HTTP_REQUEST,
+        Rack::Request.new(env)
+      )
+    end
+    let(:app) { double(:call => true) }
     let(:params) do
       {
         "controller" => "blog_posts",
@@ -19,12 +26,11 @@ if DependencyHelper.rails_present?
       }
     end
     let(:env_extra) { {} }
-    let(:app) { double(:call => true) }
     let(:env) do
       http_request_env_with_data({
         :params => params,
         :with_queue_start => true,
-        "action_dispatch.request_id" => "1",
+        "action_dispatch.request_id" => "request_id123",
         "action_dispatch.parameter_filter" => [:my_custom_param, :password],
         "action_controller.instance" => double(
           :class => MockController,
@@ -34,6 +40,9 @@ if DependencyHelper.rails_present?
     end
     let(:middleware) { Appsignal::Rack::RailsInstrumentation.new(app, {}) }
     around { |example| keep_transactions { example.run } }
+    before do
+      env[Appsignal::Rack::APPSIGNAL_TRANSACTION] = transaction
+    end
 
     describe "#call" do
       before do
@@ -43,7 +52,7 @@ if DependencyHelper.rails_present?
       context "when appsignal is active" do
         before { allow(Appsignal).to receive(:active?).and_return(true) }
 
-        it "should call with monitoring" do
+        it "calls with monitoring" do
           expect(middleware).to receive(:call_with_appsignal_monitoring).with(env)
         end
       end
@@ -51,11 +60,11 @@ if DependencyHelper.rails_present?
       context "when appsignal is not active" do
         before { allow(Appsignal).to receive(:active?).and_return(false) }
 
-        it "should not call with monitoring" do
+        it "does not call with monitoring" do
           expect(middleware).to_not receive(:call_with_appsignal_monitoring)
         end
 
-        it "should call the app" do
+        it "calls the app" do
           expect(app).to receive(:call).with(env)
         end
       end
@@ -66,36 +75,34 @@ if DependencyHelper.rails_present?
     describe "#call_with_appsignal_monitoring" do
       def run
         middleware.call(env)
+        last_transaction.complete # Manually close transaction to set sample data
       end
 
       it "calls the wrapped app" do
-        run
+        expect { run }.to_not(change { created_transactions.length })
         expect(app).to have_received(:call).with(env)
       end
 
-      it "creates one transaction with metadata" do
+      it "sets request metadata on the transaction" do
         run
 
-        expect(created_transactions.length).to eq(1)
-        transaction_hash = last_transaction.to_h
-        expect(transaction_hash).to include(
+        expect(last_transaction.to_h).to include(
           "namespace" => Appsignal::Transaction::HTTP_REQUEST,
           "action" => "MockController#index",
           "metadata" => hash_including(
             "method" => "GET",
             "path" => "/blog"
+          ),
+          "sample_data" => hash_including(
+            "tags" => { "request_id" => "request_id123" }
           )
         )
-        expect(last_transaction.ext.queue_start).to eq(
-          fixed_time * 1_000.0
-        )
       end
 
-      it "filter parameters in Rails" do
+      it "reports Rails filter parameters" do
         run
 
-        transaction_hash = last_transaction.to_h
-        expect(transaction_hash).to include(
+        expect(last_transaction.to_h).to include(
           "sample_data" => hash_including(
             "params" => params.merge(
               "my_custom_param" => "[FILTERED]",
@@ -105,6 +112,26 @@ if DependencyHelper.rails_present?
         )
       end
 
+      context "with custom params" do
+        let(:app) do
+          lambda do |env|
+            env[Appsignal::Rack::APPSIGNAL_TRANSACTION].params = { "custom_param" => "yes" }
+          end
+        end
+
+        it "allows custom params to be set" do
+          run
+
+          expect(last_transaction.to_h).to include(
+            "sample_data" => hash_including(
+              "params" => {
+                "custom_param" => "yes"
+              }
+            )
+          )
+        end
+      end
+
       context "with an invalid HTTP request method" do
         let(:env_extra) { { :request_method => "FOO", "REQUEST_METHOD" => "FOO" } }
 
@@ -113,8 +140,8 @@ if DependencyHelper.rails_present?
 
           transaction_hash = last_transaction.to_h
           expect(transaction_hash["metadata"]).to_not have_key("method")
-          expect(log_contents(log)).to contains_log(:error,
-            "Unable to report HTTP request method: '")
+          expect(log_contents(log))
+            .to contains_log(:error, "Unable to report HTTP request method: '")
         end
       end
 
@@ -137,25 +164,32 @@ if DependencyHelper.rails_present?
           )
         end
       end
-    end
 
-    describe "#request_id" do
-      subject { middleware.request_id(env) }
+      context "with a request path that's not a route" do
+        let(:env_extra) do
+          {
+            :path => "/unknown-route",
+            "action_controller.instance" => nil
+          }
+        end
 
-      context "with request id present" do
-        let(:env) { { "action_dispatch.request_id" => "id" } }
+        it "doesn't set an action name" do
+          run
 
-        it "returns the present id" do
-          is_expected.to eq "id"
+          expect(last_transaction.to_h).to include(
+            "action" => nil
+          )
         end
       end
+    end
 
-      context "with request id not present" do
-        let(:env) { {} }
+    describe "#fetch_request_id" do
+      subject { middleware.fetch_request_id(env) }
 
-        it "sets a new id" do
-          expect(subject.length).to eq 36
-        end
+      let(:env) { { "action_dispatch.request_id" => "id" } }
+
+      it "returns the action dispatch id" do
+        is_expected.to eq "id"
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appsignal
 version: !ruby/object:Gem::Version
-  version: 3.7.6
+  version: 3.8.1
 platform: ruby
 authors:
 - Robert Beekman
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-11 00:00:00.000000000 Z
+date: 2024-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -271,6 +271,7 @@ files:
 - lib/appsignal/probes/helpers.rb
 - lib/appsignal/probes/mri.rb
 - lib/appsignal/probes/sidekiq.rb
+- lib/appsignal/rack/event_handler.rb
 - lib/appsignal/rack/generic_instrumentation.rb
 - lib/appsignal/rack/rails_instrumentation.rb
 - lib/appsignal/rack/sinatra_instrumentation.rb
@@ -371,6 +372,7 @@ files:
 - spec/lib/appsignal/probes/mri_spec.rb
 - spec/lib/appsignal/probes/sidekiq_spec.rb
 - spec/lib/appsignal/probes_spec.rb
+- spec/lib/appsignal/rack/event_handler_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