newrelic_rpm 9.5.0 → 9.7.0

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

@@ -0,0 +1,105 @@
+# 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/ethon_wrappers'
+
+module NewRelic::Agent::Instrumentation
+  module Ethon
+    module NRShared
+      INSTRUMENTATION_NAME = 'Ethon'
+      NOTICEABLE_ERROR_CLASS = 'Ethon::Errors::EthonError'
+
+      def prep_easy(easy, parent = nil)
+        wrapped_request = NewRelic::Agent::HTTPClients::EthonHTTPRequest.new(easy)
+        segment = NewRelic::Agent::Tracer.start_external_request_segment(
+          library: wrapped_request.type,
+          uri: wrapped_request.uri,
+          procedure: wrapped_request.method,
+          parent: parent
+        )
+        segment.add_request_headers(wrapped_request)
+
+        callback = proc do
+          wrapped_response = NewRelic::Agent::HTTPClients::EthonHTTPResponse.new(easy)
+          segment.process_response_headers(wrapped_response)
+
+          if easy.return_code != :ok
+            e = NewRelic::Agent::NoticeableError.new(NOTICEABLE_ERROR_CLASS,
+              "return_code: >>#{easy.return_code}<<, response_code: >>#{easy.response_code}<<")
+            segment.notice_error(e)
+          end
+
+          ::NewRelic::Agent::Transaction::Segment.finish(segment)
+        end
+
+        easy.on_complete { callback.call }
+
+        segment
+      end
+
+      def wrap_with_tracing(segment, &block)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        NewRelic::Agent::Tracer.capture_segment_error(segment) do
+          yield
+        end
+      ensure
+        NewRelic::Agent::Transaction::Segment.finish(segment)
+      end
+    end
+
+    module Easy
+      include NRShared
+
+      ACTION_INSTANCE_VAR = :@nr_action
+      HEADERS_INSTANCE_VAR = :@nr_headers
+
+      # `Ethon::Easy` doesn't expose the "action name" ('GET', 'POST', etc.)
+      # and Ethon's fabrication of HTTP classes uses
+      # `Ethon::Easy::Http::Custom` for non-standard actions. To be able to
+      # know the action name at `#perform` time, we set a new instance variable
+      # on the `Ethon::Easy` instance with the base name of the fabricated
+      # class, respecting the 'Custom' name where appropriate.
+      def fabricate_with_tracing(_url, action_name, _options)
+        fabbed = yield
+        instance_variable_set(ACTION_INSTANCE_VAR, NewRelic::Agent.base_name(fabbed.class.name).upcase)
+        fabbed
+      end
+
+      # `Ethon::Easy` uses `Ethon::Easy::Header` to set request headers on
+      # libcurl with `#headers=`. After they are set, they aren't easy to get
+      # at again except via FFI so set a new instance variable on the
+      # `Ethon::Easy` instance to store them in Ruby hash format.
+      def headers_equals_with_tracing(headers)
+        instance_variable_set(HEADERS_INSTANCE_VAR, headers)
+        yield
+      end
+
+      def perform_with_tracing(*args)
+        return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+        segment = prep_easy(self)
+        wrap_with_tracing(segment) { yield }
+      end
+    end
+
+    module Multi
+      include NRShared
+
+      MULTI_SEGMENT_NAME = 'External/Multiple/Ethon::Multi/perform'
+
+      def perform_with_tracing(*args)
+        return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+        segment = NewRelic::Agent::Tracer.start_segment(name: MULTI_SEGMENT_NAME)
+
+        wrap_with_tracing(segment) do
+          easy_handles.each { |easy| prep_easy(easy, segment) }
+
+          yield
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# 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 Ethon
+    module Easy
+      module Prepend
+        include NewRelic::Agent::Instrumentation::Ethon::Easy
+
+        def fabricate(url, action_name, options)
+          fabricate_with_tracing(url, action_name, options) { super }
+        end
+
+        def headers=(headers)
+          headers_equals_with_tracing(headers) { super }
+        end
+
+        def perform(*args)
+          perform_with_tracing(*args) { super }
+        end
+      end
+    end
+
+    module Multi
+      module Prepend
+        include NewRelic::Agent::Instrumentation::Ethon::Multi
+
+        def perform(*args)
+          perform_with_tracing(*args) { super }
+        end
+      end
+    end
+  end
+end

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/fiber/instrumentation.rb

@@ -14,10 +14,7 @@ module NewRelic::Agent::Instrumentation
     def add_thread_tracing(&block)
       return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
 
-      NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-        segment_name: 'Ruby/Fiber',
-        &block
-      )
+      NewRelic::Agent::Tracer.thread_block_with_current_transaction(&block)
     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/ignorer.rb

@@ -33,7 +33,7 @@ module NewRelic::Agent::Instrumentation
         set(:newrelic_ignores, Hash.new([])) if !respond_to?(:newrelic_ignores)
 
         # If we call an ignore without a route, it applies to the whole app
-        routes = ['*'] if routes.empty?
+        routes = [::NewRelic::ASTERISK] if routes.empty?
 
         settings.newrelic_ignores[type] += routes.map do |r|
           # Ugly sending to private Base#compile, but we want to mimic

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/instrumentation/sinatra.rb

@@ -46,7 +46,7 @@ DependencyDetection.defer do
   executes do
     next unless Gem::Version.new(Sinatra::VERSION) < Gem::Version.new('2.0.0')
 
-    deprecation_msg = 'The Ruby Agent is dropping support for Sinatra versions below 2.0.0 ' \
+    deprecation_msg = 'The Ruby agent is dropping support for Sinatra versions below 2.0.0 ' \
       'in version 9.0.0. Please upgrade your Sinatra version to continue receiving full compatibility. ' \
 
     NewRelic::Agent.logger.log_once(

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

@@ -16,10 +16,7 @@ module NewRelic
         def add_thread_tracing(*args, &block)
           return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
 
-          NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-            segment_name: 'Ruby/Thread',
-            &block
-          )
+          NewRelic::Agent::Tracer.thread_block_with_current_transaction(&block)
         end
       end
     end

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

@@ -0,0 +1,21 @@
+# 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 ViewComponent::Chain
+    def self.instrument!
+      ::ViewComponent::Base.class_eval do
+        include NewRelic::Agent::Instrumentation::ViewComponent
+
+        alias_method(:render_in_without_tracing, :render_in)
+
+        def render_in(*args)
+          render_in_with_tracing(*args) do
+            render_in_without_tracing(*args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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 ViewComponent
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
+    def render_in_with_tracing(*args)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      begin
+        segment = NewRelic::Agent::Tracer.start_segment(
+          name: metric_name(self.class.identifier, self.class.name)
+        )
+        yield
+      rescue => e
+        ::NewRelic::Agent.logger.debug('Error capturing ViewComponent segment', e)
+      ensure
+        segment&.finish
+      end
+    end
+
+    def metric_name(identifier, component)
+      "View/#{metric_path(identifier)}/#{component}"
+    end
+
+    def metric_path(identifier)
+      return 'component' unless identifier
+
+      if (parts = identifier.split('/')).size > 1
+        parts[-2..-1].join('/') # Get filepath by assuming the Rails' structure: app/components/home/example_component.rb
+      else
+        NewRelic::Agent::UNKNOWN_METRIC
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# 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 ViewComponent::Prepend
+    include NewRelic::Agent::Instrumentation::ViewComponent
+
+    def render_in(*args)
+      render_in_with_tracing(*args) { super }
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# 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 'view_component/instrumentation'
+require_relative 'view_component/chain'
+require_relative 'view_component/prepend'
+
+DependencyDetection.defer do
+  named :view_component
+
+  depends_on do
+    defined?(ViewComponent) &&
+      ViewComponent::Base.method_defined?(:render_in)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ViewComponent instrumentation')
+
+    if use_prepend?
+      prepend_instrument ViewComponent::Base, NewRelic::Agent::Instrumentation::ViewComponent::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::ViewComponent::Chain
+    end
+  end
+end

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -2,7 +2,6 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require 'base64'
 require 'json'
 require 'new_relic/agent/obfuscator'
 

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