newrelic_rpm 9.5.0 → 9.6.0

data/lib/new_relic/agent/instrumentation/ethon.rb

@@ -0,0 +1,39 @@
+# 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 'ethon/instrumentation'
+require_relative 'ethon/chain'
+require_relative 'ethon/prepend'
+
+DependencyDetection.defer do
+  named :ethon
+
+  # If Ethon is being used as a dependency of Typhoeus, allow the Typhoeus
+  # instrumentation to handle everything. Otherwise each external network call
+  # will confusingly result in "Ethon" segments duplicating the information
+  # already provided by "Typhoeus" segments.
+  depends_on do
+    !defined?(Typhoeus)
+  end
+
+  depends_on do
+    defined?(Ethon) && Gem::Version.new(Ethon::VERSION) >= Gem::Version.new('0.12.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ethon instrumentation')
+  end
+
+  executes do
+    if use_prepend?
+      # NOTE: by default prepend_instrument will go with the module name that
+      #       precedes 'Prepend' (so 'Easy' and 'Multi'), but we want to use
+      #       'Ethon::Easy' and 'Ethon::Multi' so 3rd argument is supplied
+      prepend_instrument Ethon::Easy, NewRelic::Agent::Instrumentation::Ethon::Easy::Prepend, Ethon::Easy.name
+      prepend_instrument Ethon::Multi, NewRelic::Agent::Instrumentation::Ethon::Multi::Prepend, Ethon::Multi.name
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Ethon::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/httpx/chain.rb

@@ -0,0 +1,20 @@
+# 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::Agent::Instrumentation
+  module HTTPX
+    module Chain
+      def self.instrument!
+        ::HTTPX::Session.class_eval do
+          include NewRelic::Agent::Instrumentation::HTTPX
+
+          alias_method(:send_requests_without_tracing, :send_requests)
+          def send_requests(*requests)
+            send_requests_with_tracing(*requests) { send_requests_without_tracing(*requests) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/httpx/instrumentation.rb

@@ -0,0 +1,51 @@
+# 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 'new_relic/agent/http_clients/httpx_wrappers'
+
+module NewRelic::Agent::Instrumentation::HTTPX
+  INSTRUMENTATION_NAME = 'HTTPX'
+  NOTICEABLE_ERROR_CLASS = 'HTTPX::Error'
+
+  def send_requests_with_tracing(*requests)
+    NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+    requests.each { |r| nr_start_segment(r) }
+    yield
+  end
+
+  def nr_start_segment(request)
+    return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+    wrapped_request = NewRelic::Agent::HTTPClients::HTTPXHTTPRequest.new(request)
+    segment = NewRelic::Agent::Tracer.start_external_request_segment(
+      library: wrapped_request.type,
+      uri: wrapped_request.uri,
+      procedure: wrapped_request.method
+    )
+    segment.add_request_headers(wrapped_request)
+
+    request.on(:response) { nr_finish_segment.call(request, segment) }
+  end
+
+  def nr_finish_segment
+    proc do |request, segment|
+      response = @responses[request]
+
+      unless response
+        NewRelic::Agent.logger.debug('Processed an on-response callback for HTTPX but could not find the response!')
+        next
+      end
+
+      wrapped_response = NewRelic::Agent::HTTPClients::HTTPXHTTPResponse.new(response)
+      segment.process_response_headers(wrapped_response)
+
+      if response.is_a?(::HTTPX::ErrorResponse)
+        e = NewRelic::Agent::NoticeableError.new(NOTICEABLE_ERROR_CLASS, "Couldn't connect: #{response}")
+        segment.notice_error(e)
+      end
+
+      ::NewRelic::Agent::Transaction::Segment.finish(segment)
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/httpx/prepend.rb

@@ -0,0 +1,15 @@
+# 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::Agent::Instrumentation
+  module HTTPX
+    module Prepend
+      include NewRelic::Agent::Instrumentation::HTTPX
+
+      def send_requests(*requests)
+        send_requests_with_tracing(*requests) { super }
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/httpx.rb

@@ -0,0 +1,27 @@
+# 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 'httpx/chain'
+require_relative 'httpx/instrumentation'
+require_relative 'httpx/prepend'
+
+DependencyDetection.defer do
+  named :httpx
+
+  depends_on do
+    defined?(HTTPX) && Gem::Version.new(HTTPX::VERSION) >= Gem::Version.new('1.0.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing httpx instrumentation')
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument HTTPX::Session, NewRelic::Agent::Instrumentation::HTTPX::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::HTTPX::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/mongodb_command_subscriber.rb

@@ -131,10 +131,8 @@ module NewRelic
           UNKNOWN
         end
 
-        SLASH = '/'.freeze
-
         def unix_domain_socket?(host)
-          host.start_with?(SLASH)
+          host.start_with?(NewRelic::SLASH)
         end
       end
     end

data/lib/new_relic/agent/instrumentation/net_http/instrumentation.rb

@@ -35,7 +35,7 @@ module NewRelic
             segment.process_response_headers(wrapped_response)
             response
           ensure
-            segment.finish
+            segment&.finish
           end
         end
       end

data/lib/new_relic/agent/instrumentation/rails_notifications/action_controller.rb

@@ -34,6 +34,7 @@ DependencyDetection.defer do
 
     subs = %w[send_file
       send_data
+      send_stream
       redirect_to
       halted_callback
       unpermitted_parameters]

data/lib/new_relic/agent/instrumentation/roda/ignorer.rb

@@ -0,0 +1,45 @@
+# 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::Agent::Instrumentation
+  module Roda
+    module Ignorer
+      def self.should_ignore?(app, type)
+        return false unless app.opts.include?(:newrelic_ignores)
+
+        app.opts[:newrelic_ignores][type].any? do |pattern|
+          pattern === app.request.path_info
+        end
+      end
+
+      def newrelic_ignore(*routes)
+        set_newrelic_ignore(:routes, *routes)
+      end
+
+      def newrelic_ignore_apdex(*routes)
+        set_newrelic_ignore(:apdex, *routes)
+      end
+
+      def newrelic_ignore_enduser(*routes)
+        set_newrelic_ignore(:enduser, *routes)
+      end
+
+      private
+
+      def set_newrelic_ignore(type, *routes)
+        # Create a newrelic_ignores hash if one doesn't exist
+        opts[:newrelic_ignores] = Hash.new([]) if !opts.include?(:newrelic_ignores)
+
+        if routes.empty?
+          opts[:newrelic_ignores][type] += [Regexp.new('.*')]
+        else
+          opts[:newrelic_ignores][type] += routes.map do |r|
+            # Roda adds leading slashes to routes, so we need to do the same
+            "#{'/' unless r.start_with?('/')}#{r}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/roda/instrumentation.rb

@@ -51,6 +51,18 @@ module NewRelic::Agent::Instrumentation
           yield
         end
       end
+
+      def do_not_trace?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :routes)
+      end
+
+      def ignore_apdex?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :apdex)
+      end
+
+      def ignore_enduser?
+        NewRelic::Agent::Instrumentation::Roda::Ignorer.should_ignore?(self, :enduser)
+      end
     end
   end
 end

data/lib/new_relic/agent/instrumentation/roda/roda_transaction_namer.rb

@@ -9,13 +9,12 @@ module NewRelic
         module TransactionNamer
           extend self
 
-          ROOT = '/'.freeze
           REGEX_MULTIPLE_SLASHES = %r{^[/^]*(.*?)[/$?]*$}.freeze
 
           def transaction_name(request)
             path = request.path || ::NewRelic::Agent::UNKNOWN_METRIC
             name = path.gsub(REGEX_MULTIPLE_SLASHES, '\1') # remove any rogue slashes
-            name = ROOT if name.empty?
+            name = NewRelic::ROOT if name.empty?
             name = "#{request.request_method} #{name}" if request.respond_to?(:request_method)
 
             name

data/lib/new_relic/agent/instrumentation/roda.rb

@@ -4,6 +4,7 @@
 
 require_relative 'roda/instrumentation'
 require_relative 'roda/roda_transaction_namer'
+require_relative 'roda/ignorer'
 
 DependencyDetection.defer do
   named :roda
@@ -30,5 +31,6 @@ DependencyDetection.defer do
       chain_instrument NewRelic::Agent::Instrumentation::Roda::Build::Chain
       chain_instrument NewRelic::Agent::Instrumentation::Roda::Chain
     end
+    Roda.class_eval { extend NewRelic::Agent::Instrumentation::Roda::Ignorer }
   end
 end

data/lib/new_relic/agent/instrumentation/sidekiq.rb

@@ -33,7 +33,9 @@ DependencyDetection.defer do
       end
 
       if config.respond_to?(:error_handlers)
-        config.error_handlers << proc do |error, *_|
+        # Sidekiq 3.0.0 - 7.1.4 expect error_handlers to have 2 arguments
+        # Sidekiq 7.1.5+ expect error_handlers to have 3 arguments
+        config.error_handlers << proc do |error, _ctx, *_|
           NewRelic::Agent.notice_error(error)
         end
       end

data/lib/new_relic/agent/instrumentation/sinatra/transaction_namer.rb

@@ -25,14 +25,12 @@ module NewRelic
             transaction_name(::NewRelic::Agent::UNKNOWN_METRIC, request)
           end
 
-          ROOT = '/'.freeze
-
           def transaction_name(route_text, request)
             verb = http_verb(request)
 
             route_text = route_text.source if route_text.is_a?(Regexp)
             name = route_text.gsub(%r{^[/^\\A]*(.*?)[/\$\?\\z]*$}, '\1')
-            name = ROOT if name.empty?
+            name = NewRelic::ROOT if name.empty?
             name = "#{verb} #{name}" unless verb.nil?
             name
           rescue => e

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/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/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/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
 

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

@@ -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.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