newrelic_rpm 9.5.0 → 9.8.0

data/lib/new_relic/agent/llm/response_headers.rb

@@ -0,0 +1,80 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module Llm
+      module ResponseHeaders
+        ATTRIBUTES = %i[response_organization llm_version ratelimit_limit_requests
+          ratelimit_limit_tokens ratelimit_remaining_requests
+          ratelimit_remaining_tokens ratelimit_reset_requests
+          ratelimit_reset_tokens ratelimit_limit_tokens_usage_based
+          ratelimit_reset_tokens_usage_based
+          ratelimit_remaining_tokens_usage_based].freeze
+
+        ATTRIBUTE_NAME_EXCEPTIONS = {
+          response_organization: 'response.organization',
+          llm_version: 'response.headers.llmVersion',
+          ratelimit_limit_requests: 'response.headers.ratelimitLimitRequests',
+          ratelimit_limit_tokens: 'response.headers.ratelimitLimitTokens',
+          ratelimit_remaining_requests: 'response.headers.ratelimitRemainingRequests',
+          ratelimit_remaining_tokens: 'response.headers.ratelimitRemainingTokens',
+          ratelimit_reset_requests: 'response.headers.ratelimitResetRequests',
+          ratelimit_reset_tokens: 'response.headers.ratelimitResetTokens',
+          ratelimit_limit_tokens_usage_based: 'response.headers.ratelimitLimitTokensUsageBased',
+          ratelimit_reset_tokens_usage_based: 'response.headers.ratelimitResetTokensUsageBased',
+          ratelimit_remaining_tokens_usage_based: 'response.headers.ratelimitRemainingTokensUsageBased'
+        }.freeze
+
+        OPENAI_ORGANIZATION = 'openai-organization'
+        OPENAI_VERSION = 'openai-version'
+        X_RATELIMIT_LIMIT_REQUESTS = 'x-ratelimit-limit-requests'
+        X_RATELIMIT_LIMIT_TOKENS = 'x-ratelimit-limit-tokens'
+        X_RATELIMIT_REMAINING_REQUESTS = 'x-ratelimit-remaining-requests'
+        X_RATELIMIT_REMAINING_TOKENS = 'x-ratelimit-remaining-tokens'
+        X_RATELIMIT_RESET_REQUESTS = 'x-ratelimit-reset-requests'
+        X_RATELIMIT_RESET_TOKENS = 'x-ratelimit-reset-tokens'
+        X_RATELIMIT_LIMIT_TOKENS_USAGE_BASED = 'x-ratelimit-limit-tokens-usage-based'
+        X_RATELIMIT_RESET_TOKENS_USAGE_BASED = 'x-ratelimit-reset-tokens-usage-based'
+        X_RATELIMIT_REMAINING_TOKENS_USAGE_BASED = 'x-ratelimit-remaining-tokens-usage-based'
+        X_REQUEST_ID = 'x-request-id'
+
+        attr_accessor(*ATTRIBUTES)
+
+        # Headers is a hash of Net::HTTP response headers
+        def populate_openai_response_headers(headers)
+          # Embedding, ChatCompletionSummary, and ChatCompletionMessage all need
+          # request_id, so it's defined in LlmEvent. ChatCompletionMessage
+          # adds the attribute via ChatCompletionSummary.
+          self.request_id = headers[X_REQUEST_ID]&.first
+          self.response_organization = headers[OPENAI_ORGANIZATION]&.first
+          self.llm_version = headers[OPENAI_VERSION]&.first
+          self.ratelimit_limit_requests = headers[X_RATELIMIT_LIMIT_REQUESTS]&.first.to_i
+          self.ratelimit_limit_tokens = headers[X_RATELIMIT_LIMIT_TOKENS]&.first.to_i
+          remaining_headers(headers)
+          reset_headers(headers)
+          tokens_usage_based_headers(headers)
+        end
+
+        private
+
+        def remaining_headers(headers)
+          self.ratelimit_remaining_requests = headers[X_RATELIMIT_REMAINING_REQUESTS]&.first.to_i
+          self.ratelimit_remaining_tokens = headers[X_RATELIMIT_REMAINING_TOKENS]&.first.to_i
+        end
+
+        def reset_headers(headers)
+          self.ratelimit_reset_requests = headers[X_RATELIMIT_RESET_REQUESTS]&.first
+          self.ratelimit_reset_tokens = headers[X_RATELIMIT_RESET_TOKENS]&.first
+        end
+
+        def tokens_usage_based_headers(headers)
+          self.ratelimit_limit_tokens_usage_based = headers[X_RATELIMIT_LIMIT_TOKENS_USAGE_BASED]&.first.to_i
+          self.ratelimit_reset_tokens_usage_based = headers[X_RATELIMIT_RESET_TOKENS_USAGE_BASED]&.first
+          self.ratelimit_remaining_tokens_usage_based = headers[X_RATELIMIT_REMAINING_TOKENS_USAGE_BASED]&.first.to_i
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm.rb

@@ -0,0 +1,49 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'llm/llm_event'
+require_relative 'llm/chat_completion_message'
+require_relative 'llm/chat_completion_summary'
+require_relative 'llm/embedding'
+require_relative 'llm/response_headers'
+
+module NewRelic
+  module Agent
+    class LLM
+      INPUT = 'input'
+      CONTENT = 'content'
+      SEGMENT_PATTERN = %r{Llm/.+/OpenAI/.+}.freeze
+
+      def self.instrumentation_enabled?
+        NewRelic::Agent.config[:'ai_monitoring.enabled']
+      end
+
+      # LLM content-related attributes are exempt from the 4095 byte limit
+      def self.exempt_event_attribute?(type, key)
+        return false unless instrumentation_enabled?
+
+        (type == NewRelic::Agent::Llm::Embedding::EVENT_NAME && key == INPUT) ||
+          (type == NewRelic::Agent::Llm::ChatCompletionMessage::EVENT_NAME && key == CONTENT)
+      end
+
+      def self.openai?
+        @openai ||= %i[prepend chain].include?(NewRelic::Agent.config[:'instrumentation.ruby_openai']) &&
+          NewRelic::Agent.config[:'ai_monitoring.enabled']
+      end
+
+      # Used in NetHTTP instrumentation
+      def self.openai_parent?(segment)
+        return false unless openai?
+
+        segment&.parent&.name&.match?(SEGMENT_PATTERN)
+      end
+
+      def self.populate_openai_response_headers(response, parent)
+        return unless parent.instance_variable_defined?(:@llm_event)
+
+        parent.llm_event.populate_openai_response_headers(response.to_hash)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/messaging.rb

@@ -329,9 +329,9 @@ module NewRelic
 
       def transaction_name(library, destination_type, destination_name)
         transaction_name = Transaction::MESSAGE_PREFIX + library
-        transaction_name << Transaction::MessageBrokerSegment::SLASH
+        transaction_name << NewRelic::SLASH
         transaction_name << Transaction::MessageBrokerSegment::TYPES[destination_type]
-        transaction_name << Transaction::MessageBrokerSegment::SLASH
+        transaction_name << NewRelic::SLASH
 
         case destination_type
         when :queue

data/lib/new_relic/agent/monitors/synthetics_monitor.rb

@@ -5,7 +5,8 @@
 module NewRelic
   module Agent
     class SyntheticsMonitor < InboundRequestMonitor
-      SYNTHETICS_HEADER_KEY = 'HTTP_X_NEWRELIC_SYNTHETICS'.freeze
+      SYNTHETICS_HEADER_KEY = 'HTTP_X_NEWRELIC_SYNTHETICS'
+      SYNTHETICS_INFO_HEADER_KEY = 'HTTP_X_NEWRELIC_SYNTHETICS_INFO'
 
       SUPPORTED_VERSION = 1
       EXPECTED_PAYLOAD_LENGTH = 5
@@ -16,6 +17,7 @@ module NewRelic
 
       def on_before_call(request) # THREAD_LOCAL_ACCESS
         encoded_header = request[SYNTHETICS_HEADER_KEY]
+        info_header = request[SYNTHETICS_INFO_HEADER_KEY]
         return unless encoded_header
 
         incoming_payload = deserialize_header(encoded_header, SYNTHETICS_HEADER_KEY)
@@ -27,7 +29,16 @@ module NewRelic
 
         txn = Tracer.current_transaction
         txn.raw_synthetics_header = encoded_header
+        txn.raw_synthetics_info_header = info_header
         txn.synthetics_payload = incoming_payload
+        txn.synthetics_info_payload = load_json(info_header, SYNTHETICS_INFO_HEADER_KEY)
+      end
+
+      def load_json(header, key)
+        ::JSON.load(header)
+      rescue => err
+        NewRelic::Agent.logger.debug("Failure loading json header '#{key}' in #{self.class}, #{err.class}, #{err.message}")
+        nil
       end
 
       class << self

data/lib/new_relic/agent/new_relic_service/encoders.rb

@@ -2,10 +2,10 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require 'base64'
 require 'json'
 require 'stringio'
 require 'zlib'
+require 'new_relic/base64'
 
 module NewRelic
   module Agent
@@ -45,7 +45,7 @@ module NewRelic
               data = NewRelic::Agent::EncodingNormalizer.normalize_object(data)
             end
             json = ::JSON.dump(data)
-            Base64.encode64(Compressed::Deflate.encode(json))
+            NewRelic::Base64.encode64(Compressed::Deflate.encode(json))
           end
         end
       end

data/lib/new_relic/agent/new_relic_service.rb

@@ -414,7 +414,7 @@ module NewRelic
         else
           request = Net::HTTP::Post.new(opts[:uri], headers)
         end
-        @audit_logger.log_request_headers(opts[:uri], headers)
+        @audit_logger.log_request_headers(filtered_uri(opts[:uri]), headers)
         request['user-agent'] = user_agent
         request.content_type = 'application/octet-stream'
         request.body = opts[:data]
@@ -431,7 +431,7 @@ module NewRelic
         rescue *CONNECTION_ERRORS => e
           close_shared_connection
           if attempts < MAX_ATTEMPTS
-            ::NewRelic::Agent.logger.debug("Retrying request to #{opts[:collector]}#{opts[:uri]} after #{e}")
+            ::NewRelic::Agent.logger.debug("Retrying request to #{opts[:collector]}#{filtered_uri(opts[:uri])} after #{e}")
             retry
           else
             raise ServerConnectionException, "Recoverable error talking to #{@collector} after #{attempts} attempts: #{e}"
@@ -444,7 +444,7 @@ module NewRelic
 
       def attempt_request(request, opts)
         conn = http_connection
-        ::NewRelic::Agent.logger.debug("Sending request to #{opts[:collector]}#{opts[:uri]} with #{request.method}")
+        ::NewRelic::Agent.logger.debug("Sending request to #{opts[:collector]}#{filtered_uri(opts[:uri])} with #{request.method}")
         conn.request(request)
       end
 
@@ -689,9 +689,7 @@ module NewRelic
 
       def invoke_remote_send_request(method, payload, data, encoding)
         uri = remote_method_uri(method)
-        full_uri = "#{@collector}#{uri}"
-
-        @audit_logger.log_request(full_uri, payload, @marshaller)
+        @audit_logger.log_request("#{@collector}#{filtered_uri(uri)}", payload, @marshaller)
         request_send_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         response = send_request(:data => data,
           :uri       => uri,
@@ -700,6 +698,10 @@ module NewRelic
           :endpoint  => method)
         [response, request_send_ts, Process.clock_gettime(Process::CLOCK_MONOTONIC)]
       end
+
+      def filtered_uri(uri)
+        uri.gsub(license_key, ASTERISK * license_key.size)
+      end
     end
   end
 end

data/lib/new_relic/agent/obfuscator.rb

@@ -2,8 +2,6 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-# require 'base64'
-
 module NewRelic
   module Agent
     class Obfuscator

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -2,7 +2,7 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require 'base64'
+require 'new_relic/base64'
 
 module NewRelic
   module Agent
@@ -257,7 +257,7 @@ module NewRelic
           Marshal.load(data)
         rescue StandardError => e
           ::NewRelic::Agent.logger.error('Failure unmarshalling message from Resque child process', e)
-          ::NewRelic::Agent.logger.debug(Base64.encode64(data))
+          ::NewRelic::Agent.logger.debug(NewRelic::Base64.encode64(data))
           nil
         end
 

data/lib/new_relic/agent/rules_engine/segment_terms_rule.rb

@@ -8,7 +8,6 @@ module NewRelic
       class SegmentTermsRule
         PREFIX_KEY = 'prefix'.freeze
         TERMS_KEY = 'terms'.freeze
-        SEGMENT_PLACEHOLDER = '*'.freeze
         ADJACENT_PLACEHOLDERS_REGEX = %r{((?:^|/)\*)(?:/\*)*}.freeze
         ADJACENT_PLACEHOLDERS_REPLACEMENT = '\1'.freeze
 
@@ -52,7 +51,7 @@ module NewRelic
           rest = string[@trim_range]
           leading_slash = rest.slice!(LEADING_SLASH_REGEX)
           segments = rest.split(SEGMENT_SEPARATOR, -1)
-          segments.map! { |s| @terms.include?(s) ? s : SEGMENT_PLACEHOLDER }
+          segments.map! { |s| @terms.include?(s) ? s : ASTERISK }
           transformed_suffix = collapse_adjacent_placeholder_segments(segments)
 
           "#{@prefix}#{leading_slash}#{transformed_suffix}"

data/lib/new_relic/agent/rules_engine.rb

@@ -9,7 +9,7 @@ require 'new_relic/language_support'
 module NewRelic
   module Agent
     class RulesEngine
-      SEGMENT_SEPARATOR = '/'.freeze
+      SEGMENT_SEPARATOR = NewRelic::SLASH
       LEADING_SLASH_REGEX = %r{^/}.freeze
 
       include Enumerable

data/lib/new_relic/agent/span_event_primitive.rb

@@ -29,12 +29,16 @@ 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'
       ENTRY_POINT_KEY = 'nr.entryPoint'
       TRUSTED_PARENT_KEY = 'trustedParentId'
@@ -69,10 +73,12 @@ 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
-
+        intrinsics[SERVER_ADDRESS_KEY] = segment.uri.host
+        intrinsics[SERVER_PORT_KEY] = segment.uri.port
         agent_attributes = error_attributes(segment) || {}
 
         if allowed?(HTTP_URL_KEY)
@@ -86,7 +92,7 @@ module NewRelic
         [intrinsics, custom_attributes(segment), agent_attributes]
       end
 
-      def for_datastore_segment(segment)
+      def for_datastore_segment(segment) # rubocop:disable Metrics/AbcSize
         intrinsics = intrinsics_for(segment)
 
         intrinsics[COMPONENT_KEY] = segment.product
@@ -101,9 +107,15 @@ 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)

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,6 +13,8 @@ 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
@@ -172,15 +174,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/tracer.rb

@@ -357,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
 
@@ -394,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
@@ -407,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
@@ -420,16 +418,17 @@ module NewRelic
           NewRelic::Agent.config[:'instrumentation.thread.tracing']
         end
 
-        def thread_block_with_current_transaction(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?
+          current_txn = ThreadLocalStorage[:newrelic_tracer_state]&.current_transaction if ThreadLocalStorage[:newrelic_tracer_state]&.is_execution_traced?
           proc do |*args|
             begin
               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

@@ -20,7 +20,7 @@ module NewRelic
         # 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_accessor :name, :parent, :children_time, :transaction, :transaction_name, :llm_event
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
@@ -338,6 +338,9 @@ module NewRelic
 
           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

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'
@@ -63,7 +64,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 +209,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,7 +15,6 @@ module NewRelic
         PRODUCE = 'Produce'.freeze
         QUEUE = 'Queue'.freeze
         PURGE = 'Purge'.freeze
-        SLASH = '/'.freeze
         TEMP = 'Temp'.freeze
         TOPIC = 'Topic'.freeze
         UNKNOWN = 'Unknown'.freeze
@@ -73,7 +72,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

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

@@ -103,12 +103,10 @@ module NewRelic
         # rails construct the PATH_INFO enviroment variable improperly and we're generally
         # being defensive.
 
-        ROOT_PATH = '/'.freeze
-
         def path_from_request(request)
           path = attribute_from_request(request, :path) || ''
           path = HTTPClients::URIUtil.strip_query_string(path)
-          path.empty? ? ROOT_PATH : path
+          path.empty? ? NewRelic::ROOT : path
         end
 
         def content_length_from_request(request)

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

@@ -22,7 +22,7 @@ module NewRelic
 
         def add_segment(segment, parent = nil)
           segment.transaction = self
-          segment.parent = parent || current_segment
+          segment.parent = parent || thread_starting_span || current_segment
           set_current_segment(segment)
           if @segments.length < segment_limit
             @segments << segment
@@ -39,6 +39,16 @@ module NewRelic
           segment.transaction_assigned
         end
 
+        def thread_starting_span
+          # if the previous current segment was in another thread, use the thread local parent
+          if ThreadLocalStorage[:newrelic_thread_span_parent] &&
+              current_segment &&
+              current_segment.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key
+
+            ThreadLocalStorage[:newrelic_thread_span_parent]
+          end
+        end
+
         def segment_complete(segment)
           # if parent was in another thread, remove the current_segment entry for this thread
           if segment.parent && segment.parent.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key

data/lib/new_relic/agent/transaction.rb

@@ -90,7 +90,7 @@ module NewRelic
       attr_reader :transaction_trace
 
       # Fields for tracking synthetics requests
-      attr_accessor :raw_synthetics_header, :synthetics_payload
+      attr_accessor :raw_synthetics_header, :synthetics_payload, :synthetics_info_payload, :raw_synthetics_info_header
 
       # Return the currently active transaction, or nil.
       def self.tl_current
@@ -520,7 +520,7 @@ module NewRelic
       end
 
       def finish
-        return unless state.is_execution_traced?
+        return unless state.is_execution_traced? && initial_segment
 
         @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
         @duration = @end_time - @start_time
@@ -623,11 +623,24 @@ module NewRelic
           attributes.add_intrinsic_attribute(:synthetics_resource_id, synthetics_resource_id)
           attributes.add_intrinsic_attribute(:synthetics_job_id, synthetics_job_id)
           attributes.add_intrinsic_attribute(:synthetics_monitor_id, synthetics_monitor_id)
+          attributes.add_intrinsic_attribute(:synthetics_type, synthetics_info('type'))
+          attributes.add_intrinsic_attribute(:synthetics_initiator, synthetics_info('initiator'))
+
+          synthetics_additional_attributes do |key, value|
+            attributes.add_intrinsic_attribute(key, value)
+          end
         end
 
         distributed_tracer.assign_intrinsics
       end
 
+      def synthetics_additional_attributes(&block)
+        synthetics_info('attributes')&.each do |k, v|
+          new_key = "synthetics_#{NewRelic::LanguageSupport.snakeize(k.to_s)}".to_sym
+          yield(new_key, v.to_s)
+        end
+      end
+
       def calculate_gc_time
         gc_stop_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
         NewRelic::Agent::StatsEngine::GCProfiler.record_delta(gc_start_snapshot, gc_stop_snapshot)
@@ -707,6 +720,10 @@ module NewRelic
         info[4]
       end
 
+      def synthetics_info(key)
+        synthetics_info_payload[key] if synthetics_info_payload
+      end
+
       def append_apdex_perf_zone(payload)
         if recording_web_transaction?
           bucket = apdex_bucket(duration, apdex_t)
@@ -730,6 +747,12 @@ module NewRelic
         payload[:synthetics_resource_id] = synthetics_resource_id
         payload[:synthetics_job_id] = synthetics_job_id
         payload[:synthetics_monitor_id] = synthetics_monitor_id
+        payload[:synthetics_type] = synthetics_info('type')
+        payload[:synthetics_initiator] = synthetics_info('initiator')
+
+        synthetics_additional_attributes do |key, value|
+          payload[key] = value
+        end
       end
 
       def merge_metrics