appsignal 3.13.0-java → 4.0.0.beta.2-java

data/lib/appsignal/transaction.rb

@@ -9,8 +9,6 @@ module Appsignal
     # @api private
     ACTION_CABLE   = "action_cable"
     # @api private
-    FRONTEND       = "frontend"
-    # @api private
     BLANK          = ""
     # @api private
     ALLOWED_TAG_KEY_TYPES = [Symbol, String].freeze
@@ -20,69 +18,27 @@ module Appsignal
     BREADCRUMB_LIMIT = 20
     # @api private
     ERROR_CAUSES_LIMIT = 10
+    ERRORS_LIMIT = 10
 
     class << self
       # Create a new transaction and set it as the currently active
       # transaction.
       #
-      # @param id_or_namespace [String] Namespace of the to be created transaction.
+      # @param namespace [String] Namespace of the to be created transaction.
       # @return [Transaction]
-      def create(id_or_namespace, arg_namespace = nil, request = nil, options = {})
-        if id_or_namespace && arg_namespace
-          Appsignal::Utils::StdoutAndLoggerMessage.warning(
-            "Appsignal::Transaction.create: " \
-              "A new Transaction is created using the transaction ID argument. " \
-              "This argument is deprecated without replacement."
-          )
-        end
-        if arg_namespace
-          Appsignal::Utils::StdoutAndLoggerMessage.warning(
-            "Appsignal::Transaction.create: " \
-              "A Transaction is created using the namespace argument. " \
-              "Specify the namespace as the first argument to the 'create' " \
-              "method without the ID argument."
-          )
-        end
-        if request
-          Appsignal::Utils::StdoutAndLoggerMessage.warning(
-            "Appsignal::Transaction.create: " \
-              "A Transaction is created using the request argument. " \
-              "This argument is deprecated. Please use the `Appsignal.set_*` helpers instead."
-          )
-        end
-        # Allow middleware to force a new transaction
-        if options[:force]
-          Appsignal::Utils::StdoutAndLoggerMessage.warning(
-            "Appsignal::Transaction.create: " \
-              "A Transaction is created using the `:force => true` option argument. " \
-              "The options argument is deprecated without replacement."
-          )
-          Thread.current[:appsignal_transaction] = nil
-        end
-        if arg_namespace
-          id = id_or_namespace
-          namespace = arg_namespace
-        else
-          id = SecureRandom.uuid
-          namespace = id_or_namespace
-        end
-
+      def create(namespace)
         # Check if we already have a running transaction
         if Thread.current[:appsignal_transaction].nil?
           # If not, start a new transaction
-          Thread.current[:appsignal_transaction] =
-            Appsignal::Transaction.new(
-              id,
-              namespace,
-              request,
-              options
-            )
+          set_current_transaction(
+            Appsignal::Transaction.new(SecureRandom.uuid, namespace)
+          )
         else
           # Otherwise, log the issue about trying to start another transaction
           Appsignal.internal_logger.warn(
-            "Trying to start new transaction with id " \
-              "'#{id}', but a transaction with id '#{current.transaction_id}' " \
-              "is already running. Using transaction '#{current.transaction_id}'."
+            "Trying to start new transaction, but a transaction " \
+              "with id '#{current.transaction_id}' is already running. " \
+              "Using transaction '#{current.transaction_id}'."
           )
 
           # And return the current transaction instead
@@ -90,6 +46,23 @@ module Appsignal
         end
       end
 
+      # @api private
+      def set_current_transaction(transaction)
+        Thread.current[:appsignal_transaction] = transaction
+      end
+
+      # Set the current for the duration of the given block.
+      # It restores the original transaction (if any) when the block has executed.
+      #
+      # @api private
+      def with_transaction(transaction)
+        original_transaction = current if current?
+        set_current_transaction(transaction)
+        yield
+      ensure
+        set_current_transaction(original_transaction)
+      end
+
       # Returns currently active transaction or a {NilTransaction} if none is
       # active.
       #
@@ -125,11 +98,19 @@ module Appsignal
       def clear_current_transaction!
         Thread.current[:appsignal_transaction] = nil
       end
+
+      # @api private
+      def last_errors
+        @last_errors ||= []
+      end
+
+      # @api private
+      attr_writer :last_errors
     end
 
     # @api private
     attr_reader :ext, :transaction_id, :action, :namespace, :request, :paused, :tags, :options,
-      :breadcrumbs, :custom_data
+      :breadcrumbs, :is_duplicate, :error_blocks
 
     # Use {.create} to create new transactions.
     #
@@ -137,24 +118,25 @@ module Appsignal
     # @param namespace [String] Namespace of the to be created transaction.
     # @see create
     # @api private
-    def initialize(transaction_id, namespace, request = nil, options = {})
+    def initialize(transaction_id, namespace, ext: nil)
       @transaction_id = transaction_id
       @action = nil
       @namespace = namespace
-      @request = request || InternalGenericRequest.new({})
       @paused = false
       @discarded = false
       @tags = {}
-      @custom_data = nil
       @breadcrumbs = []
       @store = Hash.new({})
-      @options = options
-      @options[:params_method] ||= :params
-      @params = nil
-      @session_data = nil
-      @headers = nil
+      @error_blocks = Hash.new { |hash, key| hash[key] = [] }
+      @is_duplicate = false
+      @error_set = nil
+
+      @params = Appsignal::SampleData.new(:params)
+      @session_data = Appsignal::SampleData.new(:session_data, Hash)
+      @headers = Appsignal::SampleData.new(:headers, Hash)
+      @custom_data = Appsignal::SampleData.new(:custom_data)
 
-      @ext = Appsignal::Extension.start_transaction(
+      @ext = ext || Appsignal::Extension.start_transaction(
         @transaction_id,
         @namespace,
         0
@@ -171,8 +153,44 @@ module Appsignal
           "because it was manually discarded."
         return
       end
-      _sample_data if @ext.finish(0)
-      @ext.complete
+
+      # If the transaction is a duplicate, we don't want to finish it,
+      # because we want its finish time to be the finish time of the
+      # original transaction.
+      # Duplicate transactions should always be sampled, as we only
+      # create duplicates for errors, which are always sampled.
+      should_sample = true
+
+      unless is_duplicate
+        self.class.last_errors = @error_blocks.keys
+        should_sample = ext.finish(0)
+      end
+
+      @error_blocks.each do |error, blocks|
+        # Ignore the error that is already set in this transaction.
+        next if error == @error_set
+
+        duplicate.tap do |transaction|
+          # In the duplicate transaction for each error, set an error
+          # with a block that calls all the blocks set for that error
+          # in the original transaction.
+          transaction.set_error(error) do
+            blocks.each { |block| block.call(transaction) }
+          end
+
+          transaction.complete
+        end
+      end
+
+      if @error_set && @error_blocks[@error_set].any?
+        self.class.with_transaction(self) do
+          @error_blocks[@error_set].each do |block|
+            block.call(self)
+          end
+        end
+      end
+      sample_data if should_sample
+      ext.complete
     end
 
     # @api private
@@ -210,69 +228,48 @@ module Appsignal
       @store[key]
     end
 
-    # @api private
-    def params
-      parameters = @params || request_params
-
-      if parameters.respond_to? :call
-        parameters.call
-      else
-        parameters
-      end
-    rescue => e
-      Appsignal.internal_logger.error("Exception while fetching params: #{e.class}: #{e}")
-      nil
-    end
-
-    # Set parameters on the transaction.
-    #
-    # When no parameters are set this way, the transaction will look for
-    # parameters on the {#request} environment.
+    # Add parameters to the transaction.
     #
-    # The parameters set using {#set_params} are leading over those extracted
-    # from a request's environment.
+    # When this method is called multiple times, it will merge the request parameters.
     #
     # When both the `given_params` and a block is given to this method, the
-    # `given_params` argument is leading and the block will _not_ be called.
+    # block is leading and the argument will _not_ be used.
     #
-    # @since 3.9.1
+    # @since 4.0.0
     # @param given_params [Hash] The parameters to set on the transaction.
     # @yield This block is called when the transaction is sampled. The block's
     #   return value will become the new parameters.
     # @return [void]
-    # @see Helpers::Instrumentation#set_params
-    def set_params(given_params = nil, &block)
-      @params = block if block
-      @params = given_params if given_params
+    # @see Helpers::Instrumentation#add_params
+    def add_params(given_params = nil, &block)
+      @params.add(given_params, &block)
     end
+    alias :set_params :add_params
 
-    # @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)
+    # @api private
+    # @since 4.0.0
+    # @return [void]
+    # @see Helpers::Instrumentation#set_empty_params!
+    def set_empty_params!
+      @params.set_empty_value!
     end
 
-    # Set parameters on the transaction if not already set
+    # Add parameters to the transaction if not already set.
     #
-    # When no parameters are set this way, the transaction will look for
-    # parameters on the {#request} environment.
-    #
-    # @since 3.9.1
+    # @api private
+    # @since 4.0.0
     # @param given_params [Hash] The parameters to set on the transaction if none are already set.
     # @yield This block is called when the transaction is sampled. The block's
     #   return value will become the new parameters.
     # @return [void]
     #
-    # @see #set_params
-    # @see Helpers::Instrumentation#set_params_if_nil
-    def set_params_if_nil(given_params = nil, &block)
-      set_params(given_params, &block) unless @params
+    # @see #add_params
+    def add_params_if_nil(given_params = nil, &block)
+      add_params(given_params, &block) if !@params.value? && !@params.empty?
     end
+    alias :set_params_if_nil :add_params_if_nil
 
-    # Set tags on the transaction.
+    # Add tags to the transaction.
     #
     # When this method is called multiple times, it will merge the tags.
     #
@@ -283,32 +280,34 @@ module Appsignal
     #   The name of the tag as a String.
     # @return [void]
     #
-    # @see Helpers::Instrumentation#tag_request
+    # @see Helpers::Instrumentation#add_tags
     # @see https://docs.appsignal.com/ruby/instrumentation/tagging.html
     #   Tagging guide
-    def set_tags(given_tags = {})
+    def add_tags(given_tags = {})
       @tags.merge!(given_tags)
     end
+    alias :set_tags add_tags
 
-    # Set session data on the transaction.
+    # Add session data to the transaction.
+    #
+    # When this method is called multiple times, it will merge the session data.
     #
     # When both the `given_session_data` and a block is given to this method,
-    # the `given_session_data` argument is leading and the block will _not_ be
-    # called.
+    # the block is leading and the argument will _not_ be used.
     #
     # @param given_session_data [Hash] A hash containing session data.
     # @yield This block is called when the transaction is sampled. The block's
     #   return value will become the new session data.
     # @return [void]
     #
-    # @since 3.10.1
-    # @see Helpers::Instrumentation#set_session_data
+    # @since 4.0.0
+    # @see Helpers::Instrumentation#add_session_data
     # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
     #   Sample data guide
-    def set_session_data(given_session_data = nil, &block)
-      @session_data = block if block
-      @session_data = given_session_data if given_session_data
+    def add_session_data(given_session_data = nil, &block)
+      @session_data.add(given_session_data, &block)
     end
+    alias :set_session_data :add_session_data
 
     # Set session data on the transaction if not already set.
     #
@@ -321,73 +320,64 @@ module Appsignal
     #   return value will become the new session data.
     # @return [void]
     #
-    # @since 3.10.1
-    # @see #set_session_data
+    # @api private
+    # @since 4.0.0
+    # @see #add_session_data
     # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
     #   Sample data guide
-    def set_session_data_if_nil(given_session_data = nil, &block)
-      set_session_data(given_session_data, &block) unless @session_data
+    def add_session_data_if_nil(given_session_data = nil, &block)
+      add_session_data(given_session_data, &block) unless @session_data.value?
     end
+    alias :set_session_data_if_nil :add_session_data_if_nil
 
-    # Set headers on the transaction.
-    #
-    # When both the `given_headers` and a block is given to this method,
-    # the `given_headers` argument is leading and the block will _not_ be
-    # called.
+    # Add headers to the transaction.
     #
     # @param given_headers [Hash] A hash containing headers.
     # @yield This block is called when the transaction is sampled. The block's
     #   return value will become the new headers.
     # @return [void]
     #
-    # @since 3.10.1
-    # @see Helpers::Instrumentation#set_headers
+    # @since 4.0.0
+    # @see Helpers::Instrumentation#add_headers
     # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
     #   Sample data guide
-    def set_headers(given_headers = nil, &block)
-      @headers = block if block
-      @headers = given_headers if given_headers
+    def add_headers(given_headers = nil, &block)
+      @headers.add(given_headers, &block)
     end
+    alias :set_headers :add_headers
 
-    # Set headers on the transaction if not already set.
+    # Add headers to the transaction if not already set.
     #
     # When both the `given_headers` and a block is given to this method,
-    # the `given_headers` argument is leading and the block will _not_ be
-    # called.
+    # the block is leading and the argument will _not_ be used.
     #
     # @param given_headers [Hash] A hash containing headers.
     # @yield This block is called when the transaction is sampled. The block's
     #   return value will become the new headers.
     # @return [void]
     #
-    # @since 3.10.1
-    # @see #set_headers
+    # @api private
+    # @since 4.0.0
+    # @see #add_headers
     # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
     #   Sample data guide
-    def set_headers_if_nil(given_headers = nil, &block)
-      set_headers(given_headers, &block) unless @headers
+    def add_headers_if_nil(given_headers = nil, &block)
+      add_headers(given_headers, &block) unless @headers.value?
     end
+    alias :set_headers_if_nil :add_headers_if_nil
 
-    # Set custom data on the transaction.
+    # Add custom data to the transaction.
     #
-    # When this method is called multiple times, it will overwrite the
-    # previously set value.
-    #
-    # @since 3.10.0
-    # @see Appsignal.set_custom_data
+    # @since 4.0.0
+    # @see Helpers::Instrumentation#add_custom_data
     # @see https://docs.appsignal.com/guides/custom-data/sample-data.html
     #   Sample data guide
     # @param data [Hash/Array]
     # @return [void]
-    def set_custom_data(data)
-      case data
-      when Array, Hash
-        @custom_data = data
-      else
-        Appsignal.internal_logger
-          .error("set_custom_data: Unsupported data type #{data.class} received.")
-      end
+    def add_custom_data(data)
+      @custom_data.add(data)
     end
+    alias :set_custom_data :add_custom_data
 
     # Add breadcrumbs to the transaction.
     #
@@ -479,18 +469,6 @@ module Appsignal
       @ext.set_namespace(namespace)
     end
 
-    # @deprecated Use the {#set_action} helper.
-    # @api private
-    def set_http_or_background_action(from = request.params)
-      return unless from
-
-      group_and_action = [
-        from[:controller] || from[:class],
-        from[:action] || from[:method]
-      ]
-      set_action_if_nil(group_and_action.compact.join("#"))
-    end
-
     # Set queue start time for transaction.
     #
     # @param start [Integer] Queue start time in milliseconds.
@@ -507,35 +485,6 @@ module Appsignal
       Appsignal.internal_logger.warn("Queue start value #{start} is too big")
     end
 
-    # Set the queue time based on the HTTP header or `:queue_start` env key
-    # value.
-    #
-    # This method will first try to read the queue time from the HTTP headers
-    # `X-Request-Start` or `X-Queue-Start`. Which are parsed by Rack as
-    # `HTTP_X_QUEUE_START` and `HTTP_X_REQUEST_START`.
-    # The header value is parsed by AppSignal as either milliseconds or
-    # microseconds.
-    #
-    # If no headers are found, or the value could not be parsed, it falls back
-    # on the `:queue_start` env key on this Transaction's {request} environment
-    # (called like `request.env[:queue_start]`). This value is parsed by
-    # AppSignal as seconds.
-    #
-    # @see https://docs.appsignal.com/ruby/instrumentation/request-queue-time.html
-    # @deprecated Use {#set_queue_start} instead.
-    # @return [void]
-    def set_http_or_background_queue_start
-      Appsignal::Utils::StdoutAndLoggerMessage.warning \
-        "The Appsignal::Transaction#set_http_or_background_queue_start " \
-          "method has been deprecated. " \
-          "Please use the Appsignal::Transaction#set_queue_start method instead."
-
-      start = http_queue_start || background_queue_start
-      return unless start
-
-      set_queue_start(start)
-    end
-
     # @api private
     def set_metadata(key, value)
       return unless key && value
@@ -544,81 +493,33 @@ module Appsignal
       @ext.set_metadata(key, value)
     end
 
-    # @deprecated Use one of the set_tags, set_params, set_session_data,
-    #   set_params or set_custom_data helpers instead.
-    # @api private
-    def set_sample_data(key, data)
-      Appsignal::Utils::StdoutAndLoggerMessage.warning(
-        "Appsignal::Transaction#set_sample_data is deprecated. " \
-          "Please use one of the instrumentation helpers: set_tags, " \
-          "set_params, set_session_data, set_params or set_custom_data."
-      )
-      _set_sample_data(key, data)
-    end
-
-    # @deprecated No replacement.
-    # @api private
-    def sample_data
-      Appsignal::Utils::StdoutAndLoggerMessage.warning(
-        "Appsignal::Transaction#sample_data is deprecated. " \
-          "Please remove any calls to this method."
-      )
-      _sample_data
-    end
-
-    # @see Appsignal::Helpers::Instrumentation#set_error
-    def set_error(error)
+    # @see Appsignal::Helpers::Instrumentation#add_error
+    def add_error(error, &block)
       unless error.is_a?(Exception)
-        Appsignal.internal_logger.error "Appsignal::Transaction#set_error: Cannot set error. " \
+        Appsignal.internal_logger.error "Appsignal::Transaction#add_error: Cannot add error. " \
           "The given value is not an exception: #{error.inspect}"
         return
       end
+
       return unless error
       return unless Appsignal.active?
 
-      backtrace = cleaned_backtrace(error.backtrace)
-      @ext.set_error(
-        error.class.name,
-        cleaned_error_message(error),
-        backtrace ? Appsignal::Utils::Data.generate(backtrace) : Appsignal::Extension.data_array_new
-      )
-
-      root_cause_missing = false
-
-      causes = []
-      while error
-        error = error.cause
-
-        break unless error
+      _set_error(error) if @error_blocks.empty?
 
-        if causes.length >= ERROR_CAUSES_LIMIT
-          Appsignal.internal_logger.debug "Appsignal::Transaction#set_error: Error has more " \
-            "than #{ERROR_CAUSES_LIMIT} error causes. Only the first #{ERROR_CAUSES_LIMIT} " \
-            "will be reported."
-          root_cause_missing = true
-          break
-        end
-
-        causes << error
+      if !@error_blocks.include?(error) && @error_blocks.length >= ERRORS_LIMIT
+        Appsignal.internal_logger.warn "Appsignal::Transaction#add_error: Transaction has more " \
+          "than #{ERRORS_LIMIT} distinct errors. Only the first " \
+          "#{ERRORS_LIMIT} distinct errors will be reported."
+        return
       end
 
-      return if causes.empty?
-
-      causes_sample_data = causes.map do |e|
-        {
-          :name => e.class.name,
-          :message => cleaned_error_message(e)
-        }
-      end
+      @error_blocks[error] << block
+      @error_blocks[error].compact!
+    end
 
-      causes_sample_data.last[:is_root_cause] = false if root_cause_missing
+    alias :set_error :add_error
 
-      _set_sample_data(
-        "error_causes",
-        causes_sample_data
-      )
-    end
-    alias_method :add_exception, :set_error
+    alias_method :add_exception, :add_error
 
     # @see Helpers::Instrumentation#instrument
     # @api private
@@ -671,37 +572,56 @@ module Appsignal
     end
     alias_method :to_hash, :to_h
 
-    # @api private
-    class InternalGenericRequest
-      attr_reader :env
+    protected
 
-      def initialize(env)
-        @env = env
-      end
+    attr_writer :is_duplicate, :tags, :custom_data, :breadcrumbs, :params, :session_data, :headers
+
+    private
+
+    def _set_error(error)
+      backtrace = cleaned_backtrace(error.backtrace)
+      @ext.set_error(
+        error.class.name,
+        cleaned_error_message(error),
+        backtrace ? Appsignal::Utils::Data.generate(backtrace) : Appsignal::Extension.data_array_new
+      )
+      @error_set = error
+
+      root_cause_missing = false
+
+      causes = []
+      while error
+        error = error.cause
+
+        break unless error
+
+        if causes.length >= ERROR_CAUSES_LIMIT
+          Appsignal.internal_logger.debug "Appsignal::Transaction#add_error: Error has more " \
+            "than #{ERROR_CAUSES_LIMIT} error causes. Only the first #{ERROR_CAUSES_LIMIT} " \
+            "will be reported."
+          root_cause_missing = true
+          break
+        end
 
-      def params
-        env[:params]
+        causes << error
       end
-    end
 
-    # @deprecated Use the instrumentation helpers to set metadata on the
-    #   transaction, rather than rely on the GenericRequest automation. See the
-    #   {Helpers::Instrumentation} module for a list of helpers.
-    # @api private
-    class GenericRequest < InternalGenericRequest
-      def initialize(_env)
-        Appsignal::Utils::StdoutAndLoggerMessage.warning(
-          "The use of Appsignal::Transaction::GenericRequest is deprecated. " \
-            "Use the `Appsignal.set_*` helpers instead. " \
-            "https://docs.appsignal.com/guides/custom-data/sample-data.html"
-        )
-        super
+      causes_sample_data = causes.map do |e|
+        {
+          :name => e.class.name,
+          :message => cleaned_error_message(e)
+        }
       end
-    end
 
-    private
+      causes_sample_data.last[:is_root_cause] = false if root_cause_missing
+
+      set_sample_data(
+        "error_causes",
+        causes_sample_data
+      )
+    end
 
-    def _set_sample_data(key, data)
+    def set_sample_data(key, data)
       return unless key && data
 
       if !data.is_a?(Array) && !data.is_a?(Hash)
@@ -728,44 +648,43 @@ module Appsignal
       end
     end
 
-    def _sample_data
+    def sample_data
       {
         :params => sanitized_params,
-        :environment => sanitized_environment,
+        :environment => sanitized_request_headers,
         :session_data => sanitized_session_data,
-        :metadata => sanitized_metadata,
         :tags => sanitized_tags,
         :breadcrumbs => breadcrumbs,
         :custom_data => custom_data
       }.each do |key, data|
-        _set_sample_data(key, data)
+        set_sample_data(key, data)
       end
     end
 
-    # Returns calculated background queue start time in milliseconds, based on
-    # environment values.
-    #
-    # @return [nil] if no {#environment} is present.
-    # @return [nil] if there is no `:queue_start` in the {#environment}.
-    # @return [Integer] `:queue_start` time (in seconds) converted to milliseconds
-    def background_queue_start
-      env = environment
-      return unless env
-
-      queue_start = env[:queue_start]
-      return unless queue_start
-
-      (queue_start.to_f * 1000.0).to_i # Convert seconds to milliseconds
+    def duplicate
+      new_transaction_id = SecureRandom.uuid
+
+      self.class.new(
+        new_transaction_id,
+        namespace,
+        :ext => ext.duplicate(new_transaction_id)
+      ).tap do |transaction|
+        transaction.is_duplicate = true
+        transaction.tags = @tags.dup
+        transaction.custom_data = @custom_data.dup
+        transaction.breadcrumbs = @breadcrumbs.dup
+        transaction.params = @params.dup
+        transaction.session_data = @session_data.dup
+        transaction.headers = @headers.dup
+      end
     end
 
-    # Returns HTTP queue start time in milliseconds.
-    #
-    # @return [nil] if no queue start time is found.
-    # @return [nil] if begin time is too low to be plausible.
-    # @return [Integer] queue start in milliseconds.
-    def http_queue_start
-      env = environment
-      Appsignal::Rack::Utils.queue_start_from(env)
+    # @api private
+    def params
+      @params.value
+    rescue => e
+      Appsignal.internal_logger.error("Exception while fetching params: #{e.class}: #{e}")
+      nil
     end
 
     def sanitized_params
@@ -775,27 +694,8 @@ module Appsignal
       Appsignal::Utils::HashSanitizer.sanitize params, filter_keys
     end
 
-    def request_params
-      return unless request.respond_to?(options[:params_method])
-
-      begin
-        request.send options[:params_method]
-      rescue => e
-        Appsignal.internal_logger.warn "Exception while getting params: #{e}"
-        nil
-      end
-    end
-
     def session_data
-      if @session_data
-        if @session_data.respond_to? :call
-          @session_data.call
-        else
-          @session_data
-        end
-      elsif request.respond_to?(:session)
-        request.session
-      end
+      @session_data.value
     rescue => e
       Appsignal.internal_logger.error \
         "Exception while fetching session data: #{e.class}: #{e}"
@@ -814,35 +714,12 @@ module Appsignal
       return unless Appsignal.config[:send_session_data]
 
       Appsignal::Utils::HashSanitizer.sanitize(
-        session_data&.to_hash, Appsignal.config[:filter_session_data]
+        session_data, Appsignal.config[:filter_session_data]
       )
     end
 
-    # Returns sanitized metadata set on the request environment.
-    #
-    # @return [Hash<String, Object>]
-    def sanitized_metadata
-      env = environment
-      return unless env
-
-      metadata = env[:metadata]
-      return unless metadata
-
-      metadata
-        .transform_keys(&:to_s)
-        .reject { |key, _value| Appsignal.config[:filter_metadata].include?(key) }
-    end
-
-    def environment
-      if @headers
-        if @headers.respond_to? :call
-          @headers.call
-        else
-          @headers
-        end
-      elsif request.respond_to?(:env)
-        request.env
-      end
+    def request_headers
+      @headers.value
     rescue => e
       Appsignal.internal_logger.error \
         "Exception while fetching headers: #{e.class}: #{e}"
@@ -856,15 +733,13 @@ module Appsignal
     #
     # @return [nil] if no environment is present.
     # @return [Hash<String, Object>]
-    def sanitized_environment
-      env = environment
-      return unless env
-      return unless env.respond_to?(:empty?)
-      return if env.empty?
+    def sanitized_request_headers
+      headers = request_headers
+      return unless headers
 
       {}.tap do |out|
         Appsignal.config[:request_headers].each do |key|
-          out[key] = env[key] if env[key]
+          out[key] = headers[key] if headers[key]
         end
       end
     end
@@ -890,6 +765,13 @@ module Appsignal
       end
     end
 
+    def custom_data
+      @custom_data.value
+    rescue => e
+      Appsignal.internal_logger.error("Exception while fetching custom data: #{e.class}: #{e}")
+      nil
+    end
+
     # Clean error messages that are known to potentially contain user data.
     # Returns an unchanged message otherwise.
     def cleaned_error_message(error)