newrelic_rpm 8.0.0 → 8.4.0

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

@@ -70,7 +70,8 @@ module NewRelic::Agent::Instrumentation
         begin
           if txn_name = TransactionNamer.transaction_name_for_route(env, request)
             ::NewRelic::Agent::Transaction.set_default_transaction_name(
-              "#{self.class.name}/#{txn_name}", :sinatra)
+              "#{self.class.name}/#{txn_name}", :sinatra
+            )
           end
         rescue => e
           ::NewRelic::Agent.logger.debug("Failed during route_eval to set transaction name", e)
@@ -93,8 +94,8 @@ module NewRelic::Agent::Instrumentation
 
         name = TransactionNamer.initial_transaction_name(request)
         perform_action_with_newrelic_trace(:category => :sinatra,
-                                          :name => name,
-                                          :params => filtered_params) do
+          :name => name,
+          :params => filtered_params) do
           begin
             yield
           ensure

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

@@ -16,7 +16,7 @@ DependencyDetection.defer do
   executes do
     ::Sunspot.module_eval do
       class << self
-        %w(index index!).each do |method|
+        %w[index index!].each do |method|
           add_method_tracer method, 'SolrClient/Sunspot/index'
         end
         add_method_tracer :commit, 'SolrClient/Sunspot/commit'

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic::Agent::Instrumentation
+  module Tilt
+    module Chain
+      def self.instrument!
+        ::Tilt::Template.module_eval do
+          include NewRelic::Agent::Instrumentation::Tilt
+
+          def render_with_new_relic(*args, &block)
+            render_with_tracing(*args) {
+              render_without_newrelic(*args, &block)
+            }
+          end
+
+          alias render_without_newrelic render
+          alias render render_with_new_relic
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Tilt
+        def metric_name(klass, file)
+          "View/#{klass}/#{file}/Rendering"
+        end
+
+        # Sinatra uses #caller_locations for the file name in Tilt (unlike Rails/Rack)
+        # So here we are only grabbing the file name and name of directory it is in
+        def create_filename_for_metric(file)
+          return file unless defined?(::Sinatra) && defined?(::Sinatra::Base)
+          file.split('/')[-2..-1].join('/')
+        rescue NoMethodError
+          file
+        end
+
+        def render_with_tracing(*args, &block)
+          begin
+            finishable = Tracer.start_segment(
+              name: metric_name(self.class, create_filename_for_metric(self.file))
+            )
+            begin
+              yield
+            rescue => error
+              NewRelic::Agent.notice_error(error)
+              raise
+            end
+          ensure
+            finishable.finish if finishable
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic::Agent::Instrumentation
+  module Tilt::Prepend
+    include NewRelic::Agent::Instrumentation::Tilt
+
+    def render(*args, &block)
+      render_with_tracing { super }
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+require_relative 'tilt/instrumentation'
+require_relative 'tilt/chain'
+require_relative 'tilt/prepend'
+
+DependencyDetection.defer do
+  named :tilt
+
+  depends_on { defined?(::Tilt) }
+
+  executes do
+    ::NewRelic::Agent.logger.info('Installing Tilt instrumentation')
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument ::Tilt::Template, NewRelic::Agent::Instrumentation::Tilt::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Tilt::Chain
+    end
+  end
+end

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

@@ -4,19 +4,19 @@
 
 module NewRelic::Agent::Instrumentation
   module Typhoeus
-    module Chain 
+    module Chain
       def self.instrument!
-        ::Typhoeus::Hydra.class_eval do 
+        ::Typhoeus::Hydra.class_eval do
           include NewRelic::Agent::Instrumentation::Typhoeus
 
           def run_with_newrelic(*args)
             with_tracing { run_without_newrelic(*args) }
           end
-    
+
           alias run_without_newrelic run
           alias run run_with_newrelic
         end
       end
     end
   end
-end
+end

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

@@ -6,8 +6,7 @@ module NewRelic
   module Agent
     module Instrumentation
       module Typhoeus
-
-        HYDRA_SEGMENT_NAME    = "External/Multiple/Typhoeus::Hydra/run"
+        HYDRA_SEGMENT_NAME = "External/Multiple/Typhoeus::Hydra/run"
         NOTICIBLE_ERROR_CLASS = "Typhoeus::Errors::TyphoeusError"
 
         EARLIEST_VERSION = Gem::Version.new("0.5.3")
@@ -27,7 +26,7 @@ module NewRelic
             response.return_message
           else
             # 0.5.4 seems to have lost xxxx_message methods altogether.
-            "timeout" 
+            "timeout"
           end
         end
 
@@ -68,11 +67,10 @@ module NewRelic
             if request.response.code == 0
               segment.notice_error NoticibleError.new NOTICIBLE_ERROR_CLASS, response_message(request.response)
             end
-           
+
             segment.finish if segment
           end
           request.on_complete.unshift(callback)
-
         rescue => e
           NewRelic::Agent.logger.error("Exception during trace setup for Typhoeus request", e)
         end

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

@@ -11,4 +11,4 @@ module NewRelic::Agent::Instrumentation
       end
     end
   end
-end
+end

data/lib/new_relic/agent/internal_agent_error.rb

@@ -10,7 +10,7 @@
 module NewRelic
   module Agent
     class InternalAgentError < StandardError
-      def initialize(msg=nil)
+      def initialize(msg = nil)
         super("Ruby agent internal error. Please contact support referencing this error.\n #{msg}")
       end
     end

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -19,8 +19,8 @@ module NewRelic
 
       def log_configuration
         NewRelic::Agent.logger.debug("JS agent loader requested: #{NewRelic::Agent.config[:'browser_monitoring.loader']}",
-                                     "JS agent loader debug: #{NewRelic::Agent.config[:'browser_monitoring.debug']}",
-                                     "JS agent loader version: #{NewRelic::Agent.config[:'browser_monitoring.loader_version']}")
+          "JS agent loader debug: #{NewRelic::Agent.config[:'browser_monitoring.debug']}",
+          "JS agent loader version: #{NewRelic::Agent.config[:'browser_monitoring.loader_version']}")
 
         if !NewRelic::Agent.config[:'rum.enabled']
           NewRelic::Agent.logger.debug("Real User Monitoring is disabled for this agent. Edit your configuration to change this.")
@@ -38,19 +38,19 @@ module NewRelic
       def js_enabled_and_ready?
         if !enabled?
           ::NewRelic::Agent.logger.log_once(:debug, :js_agent_disabled,
-                                            "JS agent instrumentation is disabled.")
+            "JS agent instrumentation is disabled.")
           false
         elsif missing_config?(:js_agent_loader)
           ::NewRelic::Agent.logger.log_once(:debug, :missing_js_agent_loader,
-                                            "Missing :js_agent_loader. Skipping browser instrumentation.")
+            "Missing :js_agent_loader. Skipping browser instrumentation.")
           false
         elsif missing_config?(:beacon)
           ::NewRelic::Agent.logger.log_once(:debug, :missing_beacon,
-                                            "Beacon configuration not received (yet?). Skipping browser instrumentation.")
+            "Beacon configuration not received (yet?). Skipping browser instrumentation.")
           false
         elsif missing_config?(:browser_key)
           ::NewRelic::Agent.logger.log_once(:debug, :missing_browser_key,
-                                            "Browser key is not set. Skipping browser instrumentation.")
+            "Browser key is not set. Skipping browser instrumentation.")
           false
         else
           true
@@ -83,7 +83,7 @@ module NewRelic
         value.nil? || value.empty?
       end
 
-      def browser_timing_header(nonce=nil) #THREAD_LOCAL_ACCESS
+      def browser_timing_header(nonce = nil) # THREAD_LOCAL_ACCESS
         return '' unless js_enabled_and_ready? # fast exit
 
         state = NewRelic::Agent::Tracer.state
@@ -99,11 +99,11 @@ module NewRelic
         ''
       end
 
-      def browser_timing_loader(nonce=nil)
+      def browser_timing_loader(nonce = nil)
         html_safe_if_needed("\n<script type=\"text/javascript\"#{create_nonce(nonce)}>#{Agent.config[:js_agent_loader]}</script>")
       end
 
-      def browser_timing_config(state, nonce=nil)
+      def browser_timing_config(state, nonce = nil)
         txn = state.current_transaction
         return '' if txn.nil?
 
@@ -116,44 +116,44 @@ module NewRelic
         ''
       end
 
-      def create_nonce(nonce=nil)
+      def create_nonce(nonce = nil)
         return '' unless nonce
         " nonce=\"#{nonce.to_s}\""
       end
 
-      BEACON_KEY           = "beacon".freeze
-      ERROR_BEACON_KEY     = "errorBeacon".freeze
-      LICENSE_KEY_KEY      = "licenseKey".freeze
-      APPLICATIONID_KEY    = "applicationID".freeze
+      BEACON_KEY = "beacon".freeze
+      ERROR_BEACON_KEY = "errorBeacon".freeze
+      LICENSE_KEY_KEY = "licenseKey".freeze
+      APPLICATIONID_KEY = "applicationID".freeze
       TRANSACTION_NAME_KEY = "transactionName".freeze
-      QUEUE_TIME_KEY       = "queueTime".freeze
+      QUEUE_TIME_KEY = "queueTime".freeze
       APPLICATION_TIME_KEY = "applicationTime".freeze
-      AGENT_KEY            = "agent".freeze
-      SSL_FOR_HTTP_KEY     = "sslForHttp".freeze
-      ATTS_KEY             = "atts".freeze
-      ATTS_USER_SUBKEY     = "u".freeze
-      ATTS_AGENT_SUBKEY    = "a".freeze
+      AGENT_KEY = "agent".freeze
+      SSL_FOR_HTTP_KEY = "sslForHttp".freeze
+      ATTS_KEY = "atts".freeze
+      ATTS_USER_SUBKEY = "u".freeze
+      ATTS_AGENT_SUBKEY = "a".freeze
 
       # NOTE: Internal prototyping may override this, so leave name stable!
       def data_for_js_agent(transaction)
         queue_time_in_seconds = [transaction.queue_time, 0.0].max
         start_time_in_seconds = [transaction.start_time, 0.0].max
-        app_time_in_seconds   = Process.clock_gettime(Process::CLOCK_REALTIME) - start_time_in_seconds
+        app_time_in_seconds = Process.clock_gettime(Process::CLOCK_REALTIME) - start_time_in_seconds
 
         queue_time_in_millis = (1000.0 * queue_time_in_seconds).round
-        app_time_in_millis   = (1000.0 * app_time_in_seconds).round
+        app_time_in_millis = (1000.0 * app_time_in_seconds).round
 
         transaction_name = transaction.best_name || ::NewRelic::Agent::UNKNOWN_METRIC
 
         data = {
-          BEACON_KEY           => NewRelic::Agent.config[:beacon],
-          ERROR_BEACON_KEY     => NewRelic::Agent.config[:error_beacon],
-          LICENSE_KEY_KEY      => NewRelic::Agent.config[:browser_key],
-          APPLICATIONID_KEY    => NewRelic::Agent.config[:application_id],
+          BEACON_KEY => NewRelic::Agent.config[:beacon],
+          ERROR_BEACON_KEY => NewRelic::Agent.config[:error_beacon],
+          LICENSE_KEY_KEY => NewRelic::Agent.config[:browser_key],
+          APPLICATIONID_KEY => NewRelic::Agent.config[:application_id],
           TRANSACTION_NAME_KEY => obfuscator.obfuscate(transaction_name),
-          QUEUE_TIME_KEY       => queue_time_in_millis,
+          QUEUE_TIME_KEY => queue_time_in_millis,
           APPLICATION_TIME_KEY => app_time_in_millis,
-          AGENT_KEY            => NewRelic::Agent.config[:js_agent_file]
+          AGENT_KEY => NewRelic::Agent.config[:js_agent_file]
         }
 
         add_ssl_for_http(data)

data/lib/new_relic/agent/logging.rb

@@ -8,7 +8,6 @@ require 'new_relic/agent/hostname'
 module NewRelic
   module Agent
     module Logging
-
       # This class can be used as the formatter for an existing logger.  It
       # decorates log messages with trace and entity metadata, and formats each
       # log messages as a JSON object.
@@ -33,6 +32,7 @@ module NewRelic
         COLON = ':'.freeze
         COMMA = ','.freeze
         CLOSING_BRACE = '}'.freeze
+        REPLACEMENT_CHAR = '�'
 
         def initialize
           Agent.config.register_callback :app_name do
@@ -86,12 +86,17 @@ module NewRelic
           message << QUOTE << key << QUOTE << COLON << QUOTE << value << QUOTE
         end
 
-        def escape message
-          if String === message
-            message.to_json
-          else
-            message.inspect.to_json
+        def escape(message)
+          message = message.to_s unless message.is_a?(String)
+          unless message.encoding == Encoding::UTF_8 && message.valid_encoding?
+            message = message.encode(
+              Encoding::UTF_8,
+              invalid: :replace,
+              undef: :replace,
+              replace: REPLACEMENT_CHAR
+            )
           end
+          message.to_json
         end
 
         def clear_tags!
@@ -99,7 +104,6 @@ module NewRelic
         end
       end
 
-
       # This logger decorates logs with trace and entity metadata, and emits log
       # messages formatted as JSON objects.  It extends the Logger class from
       # the Ruby standard library, and accepts the same constructor parameters.
@@ -116,7 +120,6 @@ module NewRelic
       #
       # @api public
       class DecoratingLogger < (defined?(::ActiveSupport) && defined?(::ActiveSupport::Logger) ? ::ActiveSupport::Logger : ::Logger)
-
         alias :write :info
 
         # Positional and Keyword arguments are separated beginning with Ruby 2.7

data/lib/new_relic/agent/memory_logger.rb

@@ -44,7 +44,7 @@ module NewRelic
         messages << [:debug, msgs, blk]
       end
 
-      def log_exception(level, e, backtrace_level=level)
+      def log_exception(level, e, backtrace_level = level)
         messages << [:log_exception, [level, e, backtrace_level]]
       end
 

data/lib/new_relic/agent/messaging.rb

@@ -18,8 +18,8 @@ module NewRelic
       RABBITMQ_TRANSPORT_TYPE = "RabbitMQ"
 
       ATTR_DESTINATION = AttributeFilter::DST_TRANSACTION_EVENTS |
-                         AttributeFilter::DST_TRANSACTION_TRACER |
-                         AttributeFilter::DST_ERROR_COLLECTOR
+        AttributeFilter::DST_TRANSACTION_TRACER |
+        AttributeFilter::DST_ERROR_COLLECTOR
 
       # Start a MessageBroker segment configured to trace a messaging action.
       # Finishing this segment will handle timing and recording of the proper
@@ -53,12 +53,12 @@ module NewRelic
       # @api public
       #
       def start_message_broker_segment(action: nil,
-                                       library: nil,
-                                       destination_type: nil,
-                                       destination_name: nil,
-                                       headers: nil,
-                                       parameters: nil,
-                                       start_time: nil)
+        library: nil,
+        destination_type: nil,
+        destination_name: nil,
+        headers: nil,
+        parameters: nil,
+        start_time: nil)
 
         Tracer.start_message_broker_segment(
           action: action,
@@ -111,14 +111,14 @@ module NewRelic
       # @api public
       #
       def wrap_message_broker_consume_transaction(library:,
-                                                  destination_type:,
-                                                  destination_name:,
-                                                  headers: nil,
-                                                  routing_key: nil,
-                                                  queue_name: nil,
-                                                  exchange_type: nil,
-                                                  reply_to: nil,
-                                                  correlation_id: nil)
+        destination_type:,
+        destination_name:,
+        headers: nil,
+        routing_key: nil,
+        queue_name: nil,
+        exchange_type: nil,
+        reply_to: nil,
+        correlation_id: nil)
 
         state = Tracer.state
         return yield if state.current_transaction
@@ -181,12 +181,12 @@ module NewRelic
       # @api public
       #
       def start_amqp_publish_segment(library:,
-                                     destination_name:,
-                                     headers: nil,
-                                     routing_key: nil,
-                                     reply_to: nil,
-                                     correlation_id: nil,
-                                     exchange_type: nil)
+        destination_name:,
+        headers: nil,
+        routing_key: nil,
+        reply_to: nil,
+        correlation_id: nil,
+        exchange_type: nil)
 
         raise ArgumentError, 'missing required argument: headers' if headers.nil? && CrossAppTracing.cross_app_enabled?
 
@@ -240,12 +240,12 @@ module NewRelic
       # @api public
       #
       def start_amqp_consume_segment(library:,
-                                     destination_name:,
-                                     delivery_info:,
-                                     message_properties:,
-                                     exchange_type: nil,
-                                     queue_name: nil,
-                                     start_time: nil)
+        destination_name:,
+        delivery_info:,
+        message_properties:,
+        exchange_type: nil,
+        queue_name: nil,
+        start_time: nil)
 
         segment = Tracer.start_message_broker_segment(
           action: :consume,
@@ -301,22 +301,22 @@ module NewRelic
       # @api public
       #
       def wrap_amqp_consume_transaction library: nil,
-                                        destination_name: nil,
-                                        delivery_info: nil,
-                                        message_properties: nil,
-                                        exchange_type: nil,
-                                        queue_name: nil,
-                                        &block
+        destination_name: nil,
+        delivery_info: nil,
+        message_properties: nil,
+        exchange_type: nil,
+        queue_name: nil,
+        &block
 
         wrap_message_broker_consume_transaction library: library,
-                                                destination_type: :exchange,
-                                                destination_name: Instrumentation::Bunny.exchange_name(destination_name),
-                                                routing_key: delivery_info[:routing_key],
-                                                reply_to: message_properties[:reply_to],
-                                                queue_name: queue_name,
-                                                exchange_type: exchange_type,
-                                                headers: message_properties[:headers],
-                                                correlation_id: message_properties[:correlation_id],
+          destination_type: :exchange,
+          destination_name: Instrumentation::Bunny.exchange_name(destination_name),
+          routing_key: delivery_info[:routing_key],
+          reply_to: message_properties[:reply_to],
+          queue_name: queue_name,
+          exchange_type: exchange_type,
+          headers: message_properties[:headers],
+          correlation_id: message_properties[:correlation_id],
                                                 &block
       end
 
@@ -352,7 +352,6 @@ module NewRelic
 
         transaction_name
       end
-
     end
   end
 end

data/lib/new_relic/agent/method_tracer.rb

@@ -47,7 +47,6 @@ module NewRelic
     #
 
     module MethodTracer
-
       def self.included(klass)
         klass.extend(ClassMethods)
       end
@@ -68,7 +67,7 @@ module NewRelic
       #
       # @api public
       #
-      def trace_execution_scoped(metric_names, options=NewRelic::EMPTY_HASH) #THREAD_LOCAL_ACCESS
+      def trace_execution_scoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
         NewRelic::Agent.record_api_supportability_metric :trace_execution_scoped unless options[:internal]
         NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(metric_names, options) do
           # Using an implicit block avoids object allocation for a &block param
@@ -84,7 +83,7 @@ module NewRelic
       #
       # @api public
       #
-      def trace_execution_unscoped(metric_names, options=NewRelic::EMPTY_HASH) #THREAD_LOCAL_ACCESS
+      def trace_execution_unscoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
         NewRelic::Agent.record_api_supportability_metric :trace_execution_unscoped unless options[:internal]
         return yield unless NewRelic::Agent.tl_is_execution_traced?
         t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -103,7 +102,7 @@ module NewRelic
         module AddMethodTracer
           ALLOWED_KEYS = [:metric, :push_scope, :code_header, :code_footer].freeze
 
-          DEFAULT_SETTINGS = {:push_scope => true, :metric => true, :code_header => "", :code_footer => "" }.freeze
+          DEFAULT_SETTINGS = {:push_scope => true, :metric => true, :code_header => "", :code_footer => ""}.freeze
 
           # Checks the provided options to make sure that they make
           # sense. Raises an error if the options are incorrect to
@@ -117,7 +116,7 @@ module NewRelic
             unrecognized_keys = options.keys - ALLOWED_KEYS
             if unrecognized_keys.any?
               raise "Unrecognized options when adding method tracer to #{method_name}: " +
-                    unrecognized_keys.join(', ')
+                unrecognized_keys.join(', ')
             end
 
             options = DEFAULT_SETTINGS.merge(options)
@@ -279,8 +278,8 @@ module NewRelic
 
           prepend(_nr_traced_method_module)
 
-          ::NewRelic::Agent.logger.debug("Traced method: class = #{_nr_derived_class_name},"+
-                                         "method = #{method_name}, "+
+          ::NewRelic::Agent.logger.debug("Traced method: class = #{_nr_derived_class_name}," +
+                                         "method = #{method_name}, " +
                                          "metric = '#{metric_name}'")
         end
 
@@ -298,8 +297,8 @@ module NewRelic
         end
 
         def _nr_define_traced_method(method_name, scoped_metric: nil, unscoped_metrics: [],
-                                     code_header: nil, code_footer: nil, record_metrics: true,
-                                     visibility: :public)
+          code_header: nil, code_footer: nil, record_metrics: true,
+          visibility: :public)
           _nr_traced_method_module.module_eval do
             define_method(method_name) do |*args, &block|
               return super(*args, &block) unless NewRelic::Agent.tl_is_execution_traced?
@@ -310,9 +309,7 @@ module NewRelic
                   instance_exec(*args, &scoped_metric)
                 when String
                   scoped_metric
-                else
-                  nil
-                end
+              end
 
               unscoped_metrics_eval = unscoped_metrics.map do |metric|
                 metric.kind_of?(Proc) ? instance_exec(*args, &metric) : metric.to_s
@@ -320,20 +317,25 @@ module NewRelic
 
               instance_exec(&code_header) if code_header.kind_of?(Proc)
 
+              # NOTE: Calling ::NewRelic::Agent::MethodTracer.trace_execution_scoped and
+              # .trace_execution_unscoped below relies on the fact that MethodTracer is included
+              # in Module on agent startup. If/when this changes, these methods should be
+              # explicitly namespaced and extended in MethodTracer.
+
               # If tracing multiple metrics on this method, nest one unscoped trace inside the scoped trace.
               begin
                 if scoped_metric_eval
-                  self.class.trace_execution_scoped(scoped_metric_eval, metric: record_metrics, internal: true) do
+                  ::NewRelic::Agent::MethodTracer.trace_execution_scoped(scoped_metric_eval, metric: record_metrics, internal: true) do
                     if unscoped_metrics_eval.empty?
                       super(*args, &block)
                     else
-                      self.class.trace_execution_unscoped(unscoped_metrics_eval, internal: true) do
+                      ::NewRelic::Agent::MethodTracer.trace_execution_unscoped(unscoped_metrics_eval, internal: true) do
                         super(*args, &block)
                       end
                     end
                   end
                 elsif !unscoped_metrics_eval.empty?
-                  self.class.trace_execution_unscoped(unscoped_metrics_eval, internal: true) do
+                  ::NewRelic::Agent::MethodTracer.trace_execution_unscoped(unscoped_metrics_eval, internal: true) do
                     super(*args, &block)
                   end
                 end

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -9,12 +9,12 @@ module NewRelic
 
       extend self
 
-      def trace_execution_scoped(metric_names, options=NewRelic::EMPTY_HASH) #THREAD_LOCAL_ACCESS
+      def trace_execution_scoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
         state = NewRelic::Agent::Tracer.state
         return yield unless state.is_execution_traced?
 
         metric_names = Array(metric_names)
-        first_name   = metric_names.shift
+        first_name = metric_names.shift
         return yield unless first_name
 
         segment = NewRelic::Agent::Tracer.start_segment(