newrelic_rpm 9.1.0 → 9.21.0

data/lib/new_relic/agent/span_event_primitive.rb

@@ -29,17 +29,23 @@ module NewRelic
       CATEGORY_KEY = 'category'
       HTTP_URL_KEY = 'http.url'
       HTTP_METHOD_KEY = 'http.method'
+      HTTP_REQUEST_METHOD_KEY = 'http.request.method'
       HTTP_STATUS_CODE_KEY = 'http.statusCode'
       COMPONENT_KEY = 'component'
       DB_INSTANCE_KEY = 'db.instance'
       DB_STATEMENT_KEY = 'db.statement'
+      DB_SYSTEM_KEY = 'db.system'
       PEER_ADDRESS_KEY = 'peer.address'
       PEER_HOSTNAME_KEY = 'peer.hostname'
+      SERVER_ADDRESS_KEY = 'server.address'
+      SERVER_PORT_KEY = 'server.port'
       SPAN_KIND_KEY = 'span.kind'
+      STACKTRACE_KEY = 'code.stacktrace'
       ENTRY_POINT_KEY = 'nr.entryPoint'
       TRUSTED_PARENT_KEY = 'trustedParentId'
       TRACING_VENDORS_KEY = 'tracingVendors'
       TRANSACTION_NAME_KEY = 'transaction.name'
+      THREAD_ID_KEY = 'thread.id'
 
       # Strings for static values of the event structure
       EVENT_TYPE = 'Span'
@@ -48,6 +54,8 @@ module NewRelic
       DATASTORE_CATEGORY = 'datastore'
       CLIENT = 'client'
 
+      DB_STATEMENT_MAX_BYTES = 4096
+
       # Builds a Hash of error attributes as well as the Span ID when
       # an error is present.  Otherwise, returns nil when no error present.
       def error_attributes(segment)
@@ -69,31 +77,29 @@ module NewRelic
 
         intrinsics[COMPONENT_KEY] = segment.library
         intrinsics[HTTP_METHOD_KEY] = segment.procedure
+        intrinsics[HTTP_REQUEST_METHOD_KEY] = segment.procedure
         intrinsics[HTTP_STATUS_CODE_KEY] = segment.http_status_code if segment.http_status_code
         intrinsics[CATEGORY_KEY] = HTTP_CATEGORY
         intrinsics[SPAN_KIND_KEY] = CLIENT
-
-        agent_attributes = error_attributes(segment) || {}
+        intrinsics[SERVER_ADDRESS_KEY] = segment.uri.host
+        intrinsics[SERVER_PORT_KEY] = segment.uri.port
+        agent_attributes = {}
 
         if allowed?(HTTP_URL_KEY)
           agent_attributes[HTTP_URL_KEY] = truncate(segment.uri)
         end
 
-        if segment.respond_to?(:record_agent_attributes?) && segment.record_agent_attributes?
-          agent_attributes.merge!(agent_attributes(segment))
-        end
-
-        [intrinsics, custom_attributes(segment), agent_attributes]
+        [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
       end
 
-      def for_datastore_segment(segment)
+      def for_datastore_segment(segment) # rubocop:disable Metrics/AbcSize
         intrinsics = intrinsics_for(segment)
 
         intrinsics[COMPONENT_KEY] = segment.product
         intrinsics[SPAN_KIND_KEY] = CLIENT
         intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
 
-        agent_attributes = error_attributes(segment) || {}
+        agent_attributes = {}
 
         if segment.database_name && allowed?(DB_INSTANCE_KEY)
           agent_attributes[DB_INSTANCE_KEY] = truncate(segment.database_name)
@@ -101,17 +107,27 @@ module NewRelic
         if segment.host && segment.port_path_or_id && allowed?(PEER_ADDRESS_KEY)
           agent_attributes[PEER_ADDRESS_KEY] = truncate("#{segment.host}:#{segment.port_path_or_id}")
         end
-        if segment.host && allowed?(PEER_HOSTNAME_KEY)
-          agent_attributes[PEER_HOSTNAME_KEY] = truncate(segment.host)
+        if segment.host
+          [PEER_HOSTNAME_KEY, SERVER_ADDRESS_KEY].each do |key|
+            agent_attributes[key] = truncate(segment.host) if allowed?(key)
+          end
+        end
+        if segment.port_path_or_id&.match?(/^\d+$/) && allowed?(SERVER_PORT_KEY)
+          agent_attributes[SERVER_PORT_KEY] = segment.port_path_or_id
         end
+        agent_attributes[DB_SYSTEM_KEY] = segment.product if allowed?(DB_SYSTEM_KEY)
 
         if segment.sql_statement && allowed?(DB_STATEMENT_KEY)
-          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, 2000)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, DB_STATEMENT_MAX_BYTES)
         elsif segment.nosql_statement && allowed?(DB_STATEMENT_KEY)
-          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, DB_STATEMENT_MAX_BYTES)
+        end
+
+        if segment.params[:backtrace]
+          agent_attributes[STACKTRACE_KEY] = segment.params[:backtrace]
         end
 
-        [intrinsics, custom_attributes(segment), agent_attributes]
+        [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
       end
 
       private
@@ -125,7 +141,8 @@ module NewRelic
           PRIORITY_KEY => segment.transaction.priority,
           TIMESTAMP_KEY => milliseconds_since_epoch(segment),
           DURATION_KEY => segment.duration,
-          NAME_KEY => segment.name
+          NAME_KEY => segment.name,
+          THREAD_ID_KEY => segment.thread_id
         }
 
         # with infinite-tracing, transactions may or may not be sampled!

data/lib/new_relic/agent/sql_sampler.rb

@@ -3,7 +3,6 @@
 # frozen_string_literal: true
 
 require 'zlib'
-require 'base64'
 require 'digest/md5'
 
 module NewRelic

data/lib/new_relic/agent/system_info.rb

@@ -13,10 +13,26 @@ require 'socket'
 module NewRelic
   module Agent
     module SystemInfo
+      DOCKER_CGROUPS_V2_PATTERN = %r{.*/docker/containers/([0-9a-f]{64})/.*}.freeze
+
       def self.ruby_os_identifier
         RbConfig::CONFIG['target_os']
       end
 
+      def self.os_distribution
+        case
+        when darwin? then :darwin
+        when linux? then :linux
+        when bsd? then :bsd
+        when windows? then :windows
+        else ruby_os_identifier
+        end
+      end
+
+      def self.windows?
+        !!(ruby_os_identifier[/mingw|mswin/i])
+      end
+
       def self.darwin?
         !!(ruby_os_identifier =~ /darwin/i)
       end
@@ -172,15 +188,39 @@ module NewRelic
         proc_try_read('/proc/version')
       end
 
+      # When operating within a Docker container, attempt to obtain the
+      # container id.
+      #
+      # First look for `/proc/self/mountinfo` to exist on disk to signify
+      # cgroups v2. If that file exists, read it and expect it to contain one
+      # or more "/docker/containers/<container_id>/" lines from which the
+      # container id can be gleaned.
+      #
+      # Next look for `/proc/self/cgroup` to exist on disk to signify cgroup v1.
+      # If that file exists, read it and parse the "cpu" group info in the hope
+      # of finding a 64 character container id value.
+      #
+      # For non-cgroups based containers, use a `nil` value for the container
+      # id without generating any warnings or errors.
       def self.docker_container_id
         return unless ruby_os_identifier.include?('linux')
 
+        cgroupsv2_based_id = docker_container_id_for_cgroupsv2
+        return cgroupsv2_based_id if cgroupsv2_based_id
+
         cgroup_info = proc_try_read('/proc/self/cgroup')
         return unless cgroup_info
 
         parse_docker_container_id(cgroup_info)
       end
 
+      def self.docker_container_id_for_cgroupsv2
+        mountinfo = proc_try_read('/proc/self/mountinfo')
+        return unless mountinfo
+
+        Regexp.last_match(1) if mountinfo =~ DOCKER_CGROUPS_V2_PATTERN
+      end
+
       def self.parse_docker_container_id(cgroup_info)
         cpu_cgroup = parse_cgroup_ids(cgroup_info)['cpu']
         return unless cpu_cgroup

data/lib/new_relic/agent/threading/agent_thread.rb

@@ -9,8 +9,7 @@ module NewRelic
         def self.create(label, &blk)
           ::NewRelic::Agent.logger.debug("Creating AgentThread: #{label}")
           wrapped_blk = proc do
-            if ::Thread.current[:newrelic_tracer_state] && Thread.current[:newrelic_tracer_state].current_transaction
-              txn = ::Thread.current[:newrelic_tracer_state].current_transaction
+            if (txn = ::NewRelic::ThreadLocalStorage[:newrelic_tracer_state]&.current_transaction)
               ::NewRelic::Agent.logger.warn("AgentThread created with current transaction #{txn.best_name}")
             end
             begin

data/lib/new_relic/agent/threading/backtrace_node.rb

@@ -125,7 +125,16 @@ module NewRelic
 
         # Returns [filename, method, line number]
         def parse_backtrace_frame(frame)
-          frame =~ /([^:]*)(\:(\d+))?\:in `(.*)'/
+          # TODO: OLD RUBIES - Ruby 3.3
+          # The (?:`|') non-capturing group can be removed when the agent
+          # drops support for Ruby 3.3
+          # This group is used to capture the pre-Ruby 3.4.0 backtrace syntax.
+          # Example frame:
+          # Ruby 3.3.0 and below
+          # "irb.rb:69:in `catch'"
+          # Ruby 3.4.0+
+          # "irb.rb:69:in 'Kernel#catch'"
+          frame =~ /([^:]*)(\:(\d+))?\:in (?:`|')(.*)'/
           [$1, $4, $3] # sic
         end
       end

data/lib/new_relic/agent/tracer.rb

@@ -66,9 +66,10 @@ module NewRelic
         #
         # @api public
         def transaction_sampled?
-          if txn = current_transaction
-            txn.sampled?
-          end
+          txn = current_transaction
+          return false unless txn
+
+          txn.sampled?
         end
         alias_method :sampled?, :transaction_sampled?
 
@@ -246,7 +247,7 @@ module NewRelic
           log_error('start_segment', exception)
         end
 
-        UNKNOWN = 'Unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN
         OTHER = 'other'.freeze
 
         # Creates and starts a datastore segment used to time
@@ -356,9 +357,7 @@ module NewRelic
           yield
         rescue => exception
           # needs else branch coverage
-          if segment && segment.is_a?(Transaction::AbstractSegment) # rubocop:disable Style/SafeNavigation
-            segment.notice_error(exception)
-          end
+          segment.notice_error(exception) if segment&.is_a?(Transaction::AbstractSegment)
           raise
         end
 
@@ -393,11 +392,11 @@ module NewRelic
         #
         # If ever exposed, this requires additional synchronization
         def state_for(thread)
-          state = thread[:newrelic_tracer_state]
+          state = ThreadLocalStorage.get(thread, :newrelic_tracer_state)
 
           if state.nil?
             state = Tracer::State.new
-            thread[:newrelic_tracer_state] = state
+            ThreadLocalStorage.set(thread, :newrelic_tracer_state, state)
           end
 
           state
@@ -406,7 +405,7 @@ module NewRelic
         alias_method :tl_state_for, :state_for
 
         def clear_state
-          Thread.current[:newrelic_tracer_state] = nil
+          ThreadLocalStorage[:newrelic_tracer_state] = nil
         end
 
         alias_method :tl_clear, :clear_state
@@ -419,16 +418,17 @@ module NewRelic
           NewRelic::Agent.config[:'instrumentation.thread.tracing']
         end
 
-        def thread_block_with_current_transaction(*args, segment_name:, parent: nil, &block)
+        def thread_block_with_current_transaction(segment_name: nil, parent: nil, &block)
           parent ||= current_segment
-          current_txn = ::Thread.current[:newrelic_tracer_state]&.current_transaction if ::Thread.current[:newrelic_tracer_state]&.is_execution_traced?
-          proc do
+          current_txn = ThreadLocalStorage[:newrelic_tracer_state]&.current_transaction if ThreadLocalStorage[:newrelic_tracer_state]&.is_execution_traced?
+          proc do |*args|
             begin
-              if current_txn
+              if current_txn && !current_txn.finished?
                 NewRelic::Agent::Tracer.state.current_transaction = current_txn
+                ThreadLocalStorage[:newrelic_thread_span_parent] = parent
                 current_txn.async = true
-                segment_name += "/Thread#{::Thread.current.object_id}/Fiber#{::Fiber.current.object_id}" if NewRelic::Agent.config[:'thread_ids_enabled']
-                segment = NewRelic::Agent::Tracer.start_segment(name: segment_name, parent: parent)
+                segment_name = "#{segment_name}/Thread#{::Thread.current.object_id}/Fiber#{::Fiber.current.object_id}" if NewRelic::Agent.config[:'thread_ids_enabled']
+                segment = NewRelic::Agent::Tracer.start_segment(name: segment_name, parent: parent) if segment_name
               end
               NewRelic::Agent::Tracer.capture_segment_error(segment) do
                 yield(*args)

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -2,7 +2,6 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require 'new_relic/agent/range_extensions'
 require 'new_relic/agent/guid_generator'
 
 module NewRelic
@@ -20,14 +19,18 @@ module NewRelic
         # after its parent. We will use the optimized exclusive duration
         # calculation in all other cases.
         #
-        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_segment_key
-        attr_accessor :name, :parent, :children_time, :transaction, :transaction_name
+        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_segment_key, :thread_id
+        attr_accessor :name, :parent, :children_time, :transaction, :transaction_name, :llm_event
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
+        CALLBACK = :@callback
+        SEGMENT = 'segment'
+
         def initialize(name = nil, start_time = nil)
           @name = name
           @starting_segment_key = NewRelic::Agent::Tracer.current_segment_key
+          @thread_id = Thread.current.object_id
           @transaction_name = nil
           @transaction = nil
           @guid = NewRelic::Agent::GuidGenerator.generate_guid
@@ -50,6 +53,7 @@ module NewRelic
           @code_function = nil
           @code_lineno = nil
           @code_namespace = nil
+          invoke_callback
         end
 
         def start
@@ -105,38 +109,6 @@ module NewRelic
           @start_time.to_f..@end_time.to_f
         end
 
-        def timings_overlap?(timing1, timing2)
-          (timing1.first >= timing2.first && timing1.first <= timing2.last) ||
-            (timing2.first >= timing1.first && timing2.first <= timing1.last)
-        end
-
-        def merge_timings(timing1, timing2)
-          [([timing1.first, timing2.first].min),
-            ([timing1.last, timing2.last].max)]
-        end
-
-        # @children_timings is an array of array, with each inner array
-        # holding exactly 2 values, a child segment's start time and finish
-        # time (in that order). When it's time to record, these timings are
-        # converted into an array of range objects (using the same start and
-        # end values as the original array). Any two range objects that
-        # intersect and merged into a larger range. This checking for a
-        # intersections and merging of ranges is expensive, so the operation
-        # is only done at recording time.
-        def children_time_ranges
-          @children_time_ranges ||= begin
-            overlapped = @children_timings.each_with_object([]) do |timing, timings|
-              i = timings.index { |t| timings_overlap?(t, timing) }
-              if i
-                timings[i] = merge_timings(timing, timings[i])
-              else
-                timings << timing
-              end
-            end
-            overlapped.map { |t| Range.new(t.first, t.last) }
-          end
-        end
-
         def children_time_ranges?
           !@children_timings.empty?
         end
@@ -299,12 +271,6 @@ module NewRelic
         end
 
         def record_exclusive_duration
-          overlapping_duration = if children_time_ranges?
-            RangeExtensions.compute_overlap(time_range, children_time_ranges)
-          else
-            0.0
-          end
-
           @exclusive_duration = duration - children_time - overlapping_duration
           transaction.total_time += @exclusive_duration
           params[:exclusive_duration_millis] = @exclusive_duration * 1000 if transaction.async?
@@ -314,6 +280,51 @@ module NewRelic
           transaction.metrics
         end
 
+        def ranges_intersect?(r1, r2)
+          r1.begin > r2.begin ? r2.cover?(r1.begin) : r1.cover?(r2.begin)
+        end
+
+        def range_overlap(range)
+          return 0.0 unless ranges_intersect?(range, time_range)
+
+          [range.end, time_range.end].min - [range.begin, time_range.begin].max
+        end
+
+        # Child segments operating concurrently with this segment may have
+        # start and end times that overlap with this segment's own times. The
+        # amount of overlap needs to be removed from the `children_time` total
+        # when calculating an `@exclusive_duration` value to be added to the
+        # transaction's total time.
+        #
+        # If there aren't any child segments, return 0.0. Otherwise, take the
+        # `@children_timings` array of arrays (each array holds a child
+        # segment's start time and end time), sort it by the first elements
+        # (start times), and use the start and finish times to create Range
+        # objects. Combine all of the child segment ranges that overlap with
+        # one another into new bigger ranges. Then take those bigger ranges
+        # and calculate how much overlap there is between them and this
+        # segment's own time range. Keep a running sum of all of the overlap
+        # amounts and then return it.
+        def overlapping_duration
+          sum = 0.0
+          return sum unless children_time_ranges?
+
+          @children_timings.sort_by!(&:first)
+          range = Range.new(*@children_timings.first)
+          (1..(@children_timings.size - 1)).each do |i|
+            possible = Range.new(*@children_timings[i])
+
+            if ranges_intersect?(range, possible)
+              range = range.begin..possible.end
+            else
+              sum += range_overlap(range)
+              range = possible
+            end
+          end
+
+          sum += range_overlap(range)
+        end
+
         def transaction_state
           @transaction_state ||= if @transaction
             transaction.state
@@ -321,6 +332,57 @@ module NewRelic
             Tracer.state
           end
         end
+
+        # for segment callback usage info, see self.set_segment_callback
+        def invoke_callback
+          return unless self.class.instance_variable_defined?(CALLBACK)
+
+          NewRelic::Agent.logger.debug("Invoking callback for #{self.class.name}...")
+          self.class.instance_variable_get(CALLBACK).call
+        rescue Exception => e
+          NewRelic::Agent.logger.error("Error encountered while invoking callback for #{self.class.name}: " +
+                                       "#{e.class} - #{e.message}")
+        end
+
+        # Setting and invoking a segment callback
+        # =======================================
+        # Each individual segment class such as `ExternalRequestSegment` allows
+        # for exactly one instance of a `Proc` (meaning a proc or lambda) to be
+        # set as a callback. A callback can be set on a segment class by calling
+        # `.set_segment_callback` with a proc or lambda as the only argument.
+        # If set, the callback will be invoked with `#call` at segment class
+        # initialization time.
+        #
+        # Example usage:
+        #   callback = -> { puts 'Hello, World! }
+        #   ExternalRequestSegment.set_segment_callback(callback)
+        #   ExternalRequestSegment.new(library, uri, procedure)
+        #
+        # A callback set on a segment class will only be called when that
+        # specific segment class is initialized. Other segment classes will not
+        # be impacted.
+        #
+        # Great caution should be taken in the defining of the callback block
+        # to not have the block perform anything too time consuming or resource
+        # intensive in order to keep the New Relic Ruby agent operating
+        # normally.
+        #
+        # Given that callbacks are user defined, they must be set entirely at
+        # the user's own risk. It is recommended that each callback use
+        # conditional logic that only performs work for certain qualified
+        # segments. It is recommended that each callback be thoroughly tested
+        # in non-production environments before being introduced to production
+        # environments.
+        def self.set_segment_callback(callback_proc)
+          unless callback_proc.is_a?(Proc)
+            NewRelic::Agent.logger.error("#{self}.#{__method__}: expected an argument of type Proc, " \
+                                         "got #{callback_proc.class}")
+            return
+          end
+
+          NewRelic::Agent.record_api_supportability_metric(:set_segment_callback)
+          instance_variable_set(CALLBACK, callback_proc)
+        end
       end
     end
   end

data/lib/new_relic/agent/transaction/datastore_segment.rb

@@ -11,7 +11,7 @@ module NewRelic
   module Agent
     class Transaction
       class DatastoreSegment < Segment
-        UNKNOWN = 'unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN_LOWER
 
         attr_reader :product, :operation, :collection, :sql_statement, :nosql_statement, :host, :port_path_or_id
         attr_accessor :database_name, :record_sql

data/lib/new_relic/agent/transaction/distributed_tracer.rb

@@ -35,7 +35,7 @@ module NewRelic
         end
 
         def caller_transport_type
-          @caller_transport_type ||= 'Unknown'
+          @caller_transport_type ||= NewRelic::UNKNOWN
         end
 
         def accept_transport_type_from_api(value)
@@ -127,7 +127,7 @@ module NewRelic
         def consume_message_synthetics_headers(headers)
           synthetics_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER]
           if synthetics_header and
-              incoming_payload = ::JSON.load(deobfuscate(synthetics_header)) and
+              incoming_payload = ::JSON.parse(deobfuscate(synthetics_header)) and
               SyntheticsMonitor.is_valid_payload?(incoming_payload) and
               SyntheticsMonitor.is_supported_version?(incoming_payload) and
               SyntheticsMonitor.is_trusted?(incoming_payload)
@@ -167,7 +167,7 @@ module NewRelic
           return unless CrossAppTracing.trusted_valid_cross_app_id?(decoded_id)
 
           txn_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_TXN_HEADER]
-          txn_info = ::JSON.load(deobfuscate(txn_header))
+          txn_info = ::JSON.parse(deobfuscate(txn_header))
           payload = CrossAppPayload.new(decoded_id, transaction, txn_info)
 
           @cross_app_payload = payload

data/lib/new_relic/agent/transaction/distributed_tracing.rb

@@ -119,14 +119,13 @@ module NewRelic
         end
 
         def check_required_fields_present(payload)
-          if \
-            !payload.version.nil? &&
-                !payload.parent_account_id.nil? &&
-                !payload.parent_app_id.nil? &&
-                !payload.parent_type.nil? &&
-                (!payload.transaction_id.nil? || !payload.id.nil?) &&
-                !payload.trace_id.nil? &&
-                !payload.timestamp.nil?
+          if !payload.version.nil? &&
+              !payload.parent_account_id.nil? &&
+              !payload.parent_app_id.nil? &&
+              !payload.parent_type.nil? &&
+              (!payload.transaction_id.nil? || !payload.id.nil?) &&
+              !payload.trace_id.nil? &&
+              !payload.timestamp.nil?
 
             true
           else

data/lib/new_relic/agent/transaction/external_request_segment.rb

@@ -14,6 +14,7 @@ module NewRelic
       # @api public
       class ExternalRequestSegment < Segment
         NR_SYNTHETICS_HEADER = 'X-NewRelic-Synthetics'
+        NR_SYNTHETICS_INFO_HEADER = 'X-NewRelic-Synthetics-Info'
         APP_DATA_KEY = 'NewRelicAppData'
 
         EXTERNAL_ALL = 'External/all'
@@ -22,7 +23,6 @@ module NewRelic
         MISSING_STATUS_CODE = 'MissingHTTPStatusCode'
 
         attr_reader :library, :uri, :procedure, :http_status_code
-        attr_writer :record_agent_attributes
 
         def initialize(library, uri, procedure, start_time = nil) # :nodoc:
           @library = library
@@ -31,7 +31,6 @@ module NewRelic
           @host_header = nil
           @app_data = nil
           @http_status_code = nil
-          @record_agent_attributes = false
           super(nil, nil, start_time)
         end
 
@@ -43,14 +42,6 @@ module NewRelic
           @host_header || uri.host
         end
 
-        # By default external request segments only have errors and the http
-        # url recorded as agent attributes. To have all the agent attributes
-        # recorded, use the attr_writer like so `segment.record_agent_attributes = true`
-        # See: SpanEventPrimitive#for_external_request_segment
-        def record_agent_attributes?
-          @record_agent_attributes
-        end
-
         # This method adds New Relic request headers to a given request made to an
         # external API and checks to see if a host header is used for the request.
         # If a host header is used, it updates the segment name to match the host
@@ -63,7 +54,8 @@ module NewRelic
         def add_request_headers(request)
           process_host_header(request)
           synthetics_header = transaction&.raw_synthetics_header
-          insert_synthetics_header(request, synthetics_header) if synthetics_header
+          synthetics_info_header = transaction&.raw_synthetics_info_header
+          insert_synthetics_header(request, synthetics_header, synthetics_info_header) if synthetics_header
 
           return unless record_metrics?
 
@@ -207,8 +199,9 @@ module NewRelic
           end
         end
 
-        def insert_synthetics_header(request, header)
+        def insert_synthetics_header(request, header, info)
           request[NR_SYNTHETICS_HEADER] = header
+          request[NR_SYNTHETICS_INFO_HEADER] = info if info
         end
 
         def segment_complete

data/lib/new_relic/agent/transaction/message_broker_segment.rb

@@ -15,14 +15,15 @@ module NewRelic
         PRODUCE = 'Produce'.freeze
         QUEUE = 'Queue'.freeze
         PURGE = 'Purge'.freeze
-        SLASH = '/'.freeze
+        STREAM = 'Stream'.freeze
         TEMP = 'Temp'.freeze
         TOPIC = 'Topic'.freeze
-        UNKNOWN = 'Unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN
 
         DESTINATION_TYPES = [
           :exchange,
           :queue,
+          :stream,
           :topic,
           :temporary_queue,
           :temporary_topic,
@@ -38,6 +39,7 @@ module NewRelic
         TYPES = {
           exchange: EXCHANGE,
           temporary_queue: QUEUE,
+          stream: STREAM,
           queue: QUEUE,
           temporary_topic: TOPIC,
           topic: TOPIC,
@@ -73,7 +75,7 @@ module NewRelic
           return @name if @name
 
           @name = METRIC_PREFIX + library
-          @name << SLASH << TYPES[destination_type] << SLASH << ACTIONS[action] << SLASH
+          @name << NewRelic::SLASH << TYPES[destination_type] << NewRelic::SLASH << ACTIONS[action] << NewRelic::SLASH
 
           if destination_type == :temporary_queue || destination_type == :temporary_topic
             @name << TEMP