newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -1,10 +1,11 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction'
 require 'new_relic/agent/instrumentation/queue_time'
 require 'new_relic/agent/instrumentation/ignore_actions'
+
 module NewRelic
   module Agent
     # @api public
@@ -22,7 +23,6 @@ module NewRelic
       # @api public
       #
       module ControllerInstrumentation
-
         def self.included(clazz) # :nodoc:
           clazz.extend(ClassMethods)
         end
@@ -30,7 +30,9 @@ module NewRelic
         # This module is for importing stubs when the agent is disabled
         module ClassMethodsShim # :nodoc:
           def newrelic_ignore(*args); end
+
           def newrelic_ignore_apdex(*args); end
+
           def newrelic_ignore_enduser(*args); end
         end
 
@@ -38,15 +40,14 @@ module NewRelic
           def self.included(clazz)
             clazz.extend(ClassMethodsShim)
           end
-          def newrelic_notice_error(*args); end
-          def new_relic_trace_controller_action(*args); yield; end
+
           def perform_action_with_newrelic_trace(*args); yield; end
         end
 
-        NR_DO_NOT_TRACE_KEY   = :'@do_not_trace'   unless defined?(NR_DO_NOT_TRACE_KEY  )
-        NR_IGNORE_APDEX_KEY   = :'@ignore_apdex'   unless defined?(NR_IGNORE_APDEX_KEY  )
-        NR_IGNORE_ENDUSER_KEY = :'@ignore_enduser' unless defined?(NR_IGNORE_ENDUSER_KEY)
-        NR_DEFAULT_OPTIONS    = {}.freeze          unless defined?(NR_DEFAULT_OPTIONS   )
+        NR_DO_NOT_TRACE_KEY = :'@do_not_trace'
+        NR_IGNORE_APDEX_KEY = :'@ignore_apdex'
+        NR_IGNORE_ENDUSER_KEY = :'@ignore_enduser'
+        NR_DEFAULT_OPTIONS = NewRelic::EMPTY_HASH
 
         # @api public
         module ClassMethods
@@ -55,31 +56,44 @@ module NewRelic
           #
           # @api public
           #
-          def newrelic_ignore(specifiers={})
+          def newrelic_ignore(specifiers = {})
+            NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore)
             newrelic_ignore_aspect(NR_DO_NOT_TRACE_KEY, specifiers)
           end
+
           # Have NewRelic omit apdex measurements on the given actions.  Typically used for
           # actions that are not user facing or that skew your overall apdex measurement.
           # Accepts :except and :only options, as with #newrelic_ignore.
           #
           # @api public
           #
-          def newrelic_ignore_apdex(specifiers={})
+          def newrelic_ignore_apdex(specifiers = {})
+            NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore_apdex)
             newrelic_ignore_aspect(NR_IGNORE_APDEX_KEY, specifiers)
           end
 
           # @api public
-          def newrelic_ignore_enduser(specifiers={})
+          def newrelic_ignore_enduser(specifiers = {})
+            NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore_enduser)
             newrelic_ignore_aspect(NR_IGNORE_ENDUSER_KEY, specifiers)
           end
 
-          def newrelic_ignore_aspect(property, specifiers={}) # :nodoc:
+          def newrelic_ignore_aspect(property, specifiers = {}) # :nodoc:
             if specifiers.empty?
-              self.newrelic_write_attr property, true
-            elsif ! (Hash === specifiers)
-              ::NewRelic::Agent.logger.error "newrelic_#{property} takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')"
+              self.newrelic_write_attr(property, true)
+            elsif !(Hash === specifiers)
+              ::NewRelic::Agent.logger.error("newrelic_#{property} takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')")
             else
-              self.newrelic_write_attr property, specifiers
+              # symbolize the incoming values
+              specifiers = specifiers.inject({}) do |memo, (key, values)|
+                if values.is_a?(Array)
+                  memo[key] = values.map(&:to_sym)
+                else
+                  memo[key] = values.to_sym
+                end
+                memo
+              end
+              self.newrelic_write_attr(property, specifiers)
             end
           end
 
@@ -90,7 +104,7 @@ module NewRelic
           end
 
           def newrelic_read_attr(attr_name) # :nodoc:
-            instance_variable_get(attr_name)
+            instance_variable_get(attr_name) if instance_variable_defined?(attr_name)
           end
 
           # Add transaction tracing to the given method.  This will treat
@@ -147,11 +161,9 @@ module NewRelic
           #
           # @api public
           #
-          def add_transaction_tracer(method, options={})
-            # The metric path:
-            options[:name] ||= method.to_s
+          def add_transaction_tracer(method, options = {})
+            NewRelic::Agent.record_api_supportability_metric(:add_transaction_tracer)
 
-            argument_list = generate_argument_list(options)
             traced_method, punctuation = parse_punctuation(method)
             with_method_name, without_method_name = build_method_names(traced_method, punctuation)
 
@@ -160,20 +172,27 @@ module NewRelic
               return
             end
 
-            class_eval <<-EOC
+            # The metric path:
+            options[:name] ||= method.to_s
+
+            code_info = NewRelic::Agent::MethodTracerHelpers.code_information(self, method)
+            argument_list = generate_argument_list(options.merge(code_info))
+
+            class_eval(<<~EOC)
               def #{with_method_name}(*args, &block)
                 perform_action_with_newrelic_trace(#{argument_list.join(',')}) do
                   #{without_method_name}(*args, &block)
                  end
               end
+              ruby2_keywords(:#{with_method_name}) if respond_to?(:ruby2_keywords, true)
             EOC
 
-            visibility = NewRelic::Helper.instance_method_visibility self, method
+            visibility = NewRelic::Helper.instance_method_visibility(self, method)
 
-            alias_method without_method_name, method.to_s
-            alias_method method.to_s, with_method_name
-            send visibility, method
-            send visibility, with_method_name
+            alias_method(without_method_name, method.to_s)
+            alias_method(method.to_s, with_method_name)
+            send(visibility, method)
+            send(visibility, with_method_name)
             ::NewRelic::Agent.logger.debug("Traced transaction: class = #{self.name}, method = #{method.to_s}, options = #{options.inspect}")
           end
 
@@ -188,49 +207,54 @@ module NewRelic
               elsif key == :params
                 value.to_s
               else
-                %Q["#{value.to_s}"]
+                %Q("#{value.to_s}")
               end
 
-              %Q[:#{key} => #{value}]
+              %Q(:#{key} => #{value})
             end
           end
 
           def build_method_names(traced_method, punctuation)
-            [ "#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}",
-              "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}" ]
+            ["#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}",
+              "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}"]
           end
 
           def already_added_transaction_tracer?(target, with_method_name)
-            if NewRelic::Helper.instance_methods_include?(target, with_method_name)
-              true
-            else
-              false
-            end
+            NewRelic::Helper.instance_methods_include?(target, with_method_name)
           end
         end
 
         # @!parse extend ClassMethods
 
         class TransactionNamer
-          def self.name_for(txn, traced_obj, category, options={})
+          def self.name_for(txn, traced_obj, category, options = {})
+            return options[:transaction_name] if options[:transaction_name]
+
             "#{prefix_for_category(txn, category)}#{path_name(traced_obj, options)}"
           end
 
           def self.prefix_for_category(txn, category = nil)
-            category ||= (txn && txn.category)
+            # the following line needs else branch coverage
+            category ||= (txn && txn.category) # rubocop:disable Style/SafeNavigation
             case category
             when :controller then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
-            when :task       then ::NewRelic::Agent::Transaction::TASK_PREFIX
-            when :rack       then ::NewRelic::Agent::Transaction::RACK_PREFIX
-            when :uri        then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
-            when :sinatra    then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
+            when :web then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :task then ::NewRelic::Agent::Transaction::TASK_PREFIX
+            when :background then ::NewRelic::Agent::Transaction::TASK_PREFIX
+            when :rack then ::NewRelic::Agent::Transaction::RACK_PREFIX
+            when :uri then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :roda then ::NewRelic::Agent::Transaction::RODA_PREFIX
+            when :sinatra then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
             when :middleware then ::NewRelic::Agent::Transaction::MIDDLEWARE_PREFIX
-            when :grape      then ::NewRelic::Agent::Transaction::GRAPE_PREFIX
+            when :grape then ::NewRelic::Agent::Transaction::GRAPE_PREFIX
+            when :rake then ::NewRelic::Agent::Transaction::RAKE_PREFIX
+            when :action_cable then ::NewRelic::Agent::Transaction::ACTION_CABLE_PREFIX
+            when :message then ::NewRelic::Agent::Transaction::MESSAGE_PREFIX
             else "#{category.to_s}/" # for internal use only
             end
           end
 
-          def self.path_name(traced_obj, options={})
+          def self.path_name(traced_obj, options = {})
             return options[:path] if options[:path]
 
             class_name = class_name(traced_obj, options)
@@ -247,9 +271,10 @@ module NewRelic
             end
           end
 
-          def self.class_name(traced_obj, options={})
+          def self.class_name(traced_obj, options = {})
             return options[:class_name] if options[:class_name]
-            if (traced_obj.is_a?(Class) || traced_obj.is_a?(Module))
+
+            if traced_obj.is_a?(Class) || traced_obj.is_a?(Module)
               traced_obj.name
             else
               traced_obj.class.name
@@ -258,7 +283,7 @@ module NewRelic
         end
 
         # Yield to the given block with NewRelic tracing.  Used by
-        # default instrumentation on controller actions in Rails and Merb.
+        # default instrumentation on controller actions in Rails.
         # But it can also be used in custom instrumentation of controller
         # methods and background tasks.
         #
@@ -315,7 +340,7 @@ module NewRelic
         #
         # Seldomly used options:
         #
-        # * <tt>:class_name => aClass.name</tt> is used to override the name
+        # * <tt>:class_name => Class.name</tt> is used to override the name
         #   of the class when used inside the metric name.  Default is the
         #   current class.
         # * <tt>:path => metric_path</tt> is *deprecated* in the public API.  It
@@ -326,14 +351,16 @@ module NewRelic
         #
         # @api public
         #
-        def perform_action_with_newrelic_trace(*args, &block) #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
-          state.request = newrelic_request(args)
+        def perform_action_with_newrelic_trace(*args, &block) # THREAD_LOCAL_ACCESS
+          NewRelic::Agent.record_api_supportability_metric(:perform_action_with_newrelic_trace)
+          state = NewRelic::Agent::Tracer.state
+          request = newrelic_request(args)
+          queue_start_time = detect_queue_start_time(request)
 
           skip_tracing = do_not_trace? || !state.is_execution_traced?
 
           if skip_tracing
-            state.current_transaction.ignore! if state.current_transaction
+            state.current_transaction&.ignore!
             NewRelic::Agent.disable_all_tracing { return yield }
           end
 
@@ -342,11 +369,15 @@ module NewRelic
           # the *args method signature to ensure backwards compatibility.
 
           trace_options = args.last.is_a?(Hash) ? args.last : NR_DEFAULT_OPTIONS
-          category      = trace_options[:category] || :controller
-          txn_options   = create_transaction_options(trace_options, category, state)
+          category = trace_options[:category] || :controller
+          txn_options = create_transaction_options(trace_options, category, state, queue_start_time)
 
           begin
-            txn = Transaction.start(state, category, txn_options)
+            finishable = Tracer.start_transaction_or_segment(
+              name: txn_options[:transaction_name],
+              category: category,
+              options: txn_options
+            )
 
             begin
               yield
@@ -354,13 +385,9 @@ module NewRelic
               NewRelic::Agent.notice_error(e)
               raise
             end
-
           ensure
-            if txn
-              txn.ignore_apdex!   if ignore_apdex?
-              txn.ignore_enduser! if ignore_enduser?
-            end
-            Transaction.stop(state)
+            # the following line needs else branch coverage
+            finishable.finish if finishable # rubocop:disable Style/SafeNavigation
           end
         end
 
@@ -373,15 +400,14 @@ module NewRelic
             opts[:request]
           # in a Rails app
           elsif self.respond_to?(:request)
-            self.request
+            self.request rescue nil
           end
         end
 
         # Should be implemented in the dispatcher class
         def newrelic_response_code; end
 
-        def newrelic_request_headers(state)
-          request = state.request
+        def newrelic_request_headers(request)
           if request
             if request.respond_to?(:headers)
               request.headers
@@ -391,14 +417,14 @@ module NewRelic
           end
         end
 
-        # overrideable method to determine whether to trace an action
+        # overridable method to determine whether to trace an action
         # or not - you may override this in your controller and supply
         # your own logic for ignoring transactions.
         def do_not_trace?
           _is_filtered?(NR_DO_NOT_TRACE_KEY)
         end
 
-        # overrideable method to determine whether to trace an action
+        # overridable method to determine whether to trace an action
         # for purposes of apdex measurement - you can use this to
         # ignore things like api calls or other fast non-user-facing
         # actions
@@ -412,14 +438,19 @@ module NewRelic
 
         private
 
-        def create_transaction_options(trace_options, category, state)
+        def create_transaction_options(trace_options, category, state, queue_start_time)
           txn_options = {}
-          txn_options[:request]   = trace_options[:request]
-          txn_options[:request] ||= request if respond_to?(:request)
+          txn_options[:request] = trace_options[:request]
+          txn_options[:request] ||= request if respond_to?(:request) rescue nil
           # params should have been filtered before calling perform_action_with_newrelic_trace
           txn_options[:filtered_params] = trace_options[:params]
           txn_options[:transaction_name] = TransactionNamer.name_for(nil, self, category, trace_options)
-          txn_options[:apdex_start_time] = detect_queue_start_time(state)
+          txn_options[:apdex_start_time] = queue_start_time
+          txn_options[:ignore_apdex] = ignore_apdex?
+          txn_options[:ignore_enduser] = ignore_enduser?
+          NewRelic::Agent::MethodTracerHelpers::SOURCE_CODE_INFORMATION_PARAMETERS.each do |parameter|
+            txn_options[parameter] = trace_options[parameter]
+          end
           txn_options
         end
 
@@ -435,11 +466,12 @@ module NewRelic
           NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
             key,
             self.class,
-            name)
+            name
+          )
         end
 
-        def detect_queue_start_time(state)
-          headers = newrelic_request_headers(state)
+        def detect_queue_start_time(request)
+          headers = newrelic_request_headers(request)
 
           QueueTime.parse_frontend_timestamp(headers) if headers
         end

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

@@ -0,0 +1,91 @@
+# 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 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module Curb
+    module Chain
+      def self.instrument! # rubocop:disable Metrics/AbcSize
+        Curl::Easy.class_eval do
+          include NewRelic::Agent::Instrumentation::Curb::Easy
+
+          def http_head_with_newrelic(*args, &blk)
+            http_head_with_tracing { http_head_without_newrelic(*args, &blk) }
+          end
+
+          alias_method(:http_head_without_newrelic, :http_head)
+          alias_method(:http_head, :http_head_with_newrelic)
+
+          def http_post_with_newrelic(*args, &blk)
+            http_post_with_tracing { http_post_without_newrelic(*args, &blk) }
+          end
+
+          alias_method(:http_post_without_newrelic, :http_post)
+          alias_method(:http_post, :http_post_with_newrelic)
+
+          def http_put_with_newrelic(*args, &blk)
+            http_put_with_tracing { http_put_without_newrelic(*args, &blk) }
+          end
+
+          alias_method(:http_put_without_newrelic, :http_put)
+          alias_method(:http_put, :http_put_with_newrelic)
+
+          # Hook the #http method to set the verb.
+          def http_with_newrelic(verb)
+            http_with_tracing(verb) { http_without_newrelic(verb) }
+          end
+
+          alias_method(:http_without_newrelic, :http)
+          alias_method(:http, :http_with_newrelic)
+
+          # Hook the #perform method to mark the request as non-parallel.
+          def perform_with_newrelic
+            perform_with_tracing { perform_without_newrelic }
+          end
+
+          alias_method(:perform_without_newrelic, :perform)
+          alias_method(:perform, :perform_with_newrelic)
+
+          # Record the HTTP verb for future #perform calls
+          def method_with_newrelic(verb)
+            method_with_tracing(verb) { method_without_newrelic(verb) }
+          end
+
+          alias_method(:method_without_newrelic, :method)
+          alias_method(:method, :method_with_newrelic)
+
+          # We override this method in order to ensure access to header_str even
+          # though we use an on_header callback
+          def header_str_with_newrelic
+            header_str_with_tracing { header_str_without_newrelic }
+          end
+
+          alias_method(:header_str_without_newrelic, :header_str)
+          alias_method(:header_str, :header_str_with_newrelic)
+        end
+
+        Curl::Multi.class_eval do
+          include NewRelic::Agent::Instrumentation::Curb::Multi
+
+          # Add CAT with callbacks if the request is serial
+          def add_with_newrelic(curl)
+            add_with_tracing(curl) { add_without_newrelic(curl) }
+          end
+
+          alias_method(:add_without_newrelic, :add)
+          alias_method(:add, :add_with_newrelic)
+
+          # Trace as an External/Multiple call if the first request isn't serial.
+          def perform_with_newrelic(&blk)
+            perform_with_tracing { perform_without_newrelic(&blk) }
+          end
+
+          alias_method(:perform_without_newrelic, :perform)
+          alias_method(:perform, :perform_with_newrelic)
+        end
+      end
+    end
+  end
+end