newrelic_rpm 7.0.0 → 8.8.0

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

@@ -22,7 +22,6 @@ module NewRelic
       # @api public
       #
       module ControllerInstrumentation
-
         def self.included(clazz) # :nodoc:
           clazz.extend(ClassMethods)
         end
@@ -30,7 +29,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,14 +39,16 @@ module NewRelic
           def self.included(clazz)
             clazz.extend(ClassMethodsShim)
           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'
-        NR_IGNORE_APDEX_KEY   = :'@ignore_apdex'
+        NR_DO_NOT_TRACE_KEY = :'@do_not_trace'
+        NR_IGNORE_APDEX_KEY = :'@ignore_apdex'
         NR_IGNORE_ENDUSER_KEY = :'@ignore_enduser'
-        NR_DEFAULT_OPTIONS    = {}.freeze
+        NR_DEFAULT_OPTIONS = {}.freeze
 
         # @api public
         module ClassMethods
@@ -54,31 +57,32 @@ 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)
+            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
               # symbolize the incoming values
@@ -158,13 +162,9 @@ module NewRelic
           #
           # @api public
           #
-          def add_transaction_tracer(method, options={})
+          def add_transaction_tracer(method, options = {})
             NewRelic::Agent.record_api_supportability_metric(:add_transaction_tracer)
 
-            # The metric path:
-            options[:name] ||= method.to_s
-
-            argument_list = generate_argument_list(options)
             traced_method, punctuation = parse_punctuation(method)
             with_method_name, without_method_name = build_method_names(traced_method, punctuation)
 
@@ -173,12 +173,19 @@ module NewRelic
               return
             end
 
+            # 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
@@ -201,54 +208,50 @@ 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 = {})
             "#{prefix_for_category(txn, category)}#{path_name(traced_obj, options)}"
           end
 
           def self.prefix_for_category(txn, category = nil)
             category ||= (txn && txn.category)
             case category
-            when :controller    then ::NewRelic::Agent::Transaction::CONTROLLER_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 :sinatra       then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
-            when :middleware    then ::NewRelic::Agent::Transaction::MIDDLEWARE_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
+            when :controller then ::NewRelic::Agent::Transaction::CONTROLLER_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 :sinatra then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
+            when :middleware then ::NewRelic::Agent::Transaction::MIDDLEWARE_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)
@@ -265,9 +268,9 @@ 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
@@ -276,7 +279,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.
         #
@@ -344,7 +347,7 @@ module NewRelic
         #
         # @api public
         #
-        def perform_action_with_newrelic_trace(*args, &block) #THREAD_LOCAL_ACCESS
+        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)
@@ -362,8 +365,8 @@ 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, queue_start_time)
+          category = trace_options[:category] || :controller
+          txn_options = create_transaction_options(trace_options, category, state, queue_start_time)
 
           begin
             finishable = Tracer.start_transaction_or_segment(
@@ -378,7 +381,6 @@ module NewRelic
               NewRelic::Agent.notice_error(e)
               raise
             end
-
           ensure
             finishable.finish if finishable
           end
@@ -433,7 +435,7 @@ module NewRelic
 
         def create_transaction_options(trace_options, category, state, queue_start_time)
           txn_options = {}
-          txn_options[:request]   = trace_options[: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]
@@ -441,6 +443,9 @@ module NewRelic
           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
 
@@ -456,7 +461,8 @@ module NewRelic
           NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
             key,
             self.class,
-            name)
+            name
+          )
         end
 
         def detect_queue_start_time(request)

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

@@ -15,77 +15,76 @@ module NewRelic::Agent::Instrumentation
           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 ) }
+            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 { method_without_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 
+        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

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

@@ -9,51 +9,50 @@ module NewRelic
       module Curb
         module Easy
           attr_accessor :_nr_instrumented,
-                        :_nr_failure_instrumented,
-                        :_nr_http_verb,
-                        :_nr_header_str,
-                        :_nr_original_on_header,
-                        :_nr_original_on_complete,
-                        :_nr_original_on_failure,
-                        :_nr_serial
-    
+            :_nr_failure_instrumented,
+            :_nr_http_verb,
+            :_nr_header_str,
+            :_nr_original_on_header,
+            :_nr_original_on_complete,
+            :_nr_original_on_failure,
+            :_nr_serial
+
           # We have to hook these three methods separately, as they don't use
           # Curl::Easy#http
           def http_head_with_tracing
             self._nr_http_verb = :HEAD
             yield
           end
-    
+
           def http_post_with_tracing
             self._nr_http_verb = :POST
             yield
           end
-    
-    
+
           def http_put_with_tracing
             self._nr_http_verb = :PUT
             yield
           end
-    
+
           # Hook the #http method to set the verb.
           def http_with_tracing verb
             self._nr_http_verb = verb.to_s.upcase
             yield
           end
-    
+
           # Hook the #perform method to mark the request as non-parallel.
           def perform_with_tracing
             self._nr_http_verb ||= :GET
             self._nr_serial = true
             yield
           end
-    
+
           # Record the HTTP verb for future #perform calls
           def method_with_tracing verb
             self._nr_http_verb = verb.upcase
             yield
           end
-    
+
           # We override this method in order to ensure access to header_str even
           # though we use an on_header callback
           def header_str_with_tracing
@@ -65,9 +64,8 @@ module NewRelic
               yield
             end
           end
-
         end
-####################################################
+        ####################################################
 
         module Multi
           include NewRelic::Agent::MethodTracer
@@ -77,14 +75,14 @@ module NewRelic
             if curl.respond_to?(:_nr_serial) && curl._nr_serial
               hook_pending_request(curl) if NewRelic::Agent::Tracer.tracing_enabled?
             end
-    
+
             return yield
           end
 
           # Trace as an External/Multiple call if the first request isn't serial.
           def perform_with_tracing
             return yield if first_request_is_serial?
-    
+
             trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
               yield
             end
@@ -94,15 +92,15 @@ module NewRelic
           # and set up cross-application tracing if it's enabled.
           def hook_pending_request(request)
             wrapped_request, wrapped_response = wrap_request(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
-    
+
             # install all callbacks
             unless request._nr_instrumented
               install_header_callback(request, wrapped_response)
@@ -113,8 +111,7 @@ module NewRelic
           rescue => err
             NewRelic::Agent.logger.error("Untrapped exception", err)
           end
-    
-    
+
           # Create request and response adapter objects for the specified +request+
           # NOTE: Although strange to wrap request and response at once, it works
           # because curb's callback mechanism updates the instantiated wrappers
@@ -123,7 +120,7 @@ module NewRelic
             return NewRelic::Agent::HTTPClients::CurbRequest.new(request),
                     NewRelic::Agent::HTTPClients::CurbResponse.new(request)
           end
-    
+
           # Install a callback that will record the response headers
           # to enable CAT linking
           def install_header_callback(request, wrapped_response)
@@ -139,7 +136,7 @@ module NewRelic
               end
             end
           end
-    
+
           # Install a callback that will finish the trace.
           def install_completion_callback(request, wrapped_response, segment)
             original_callback = request.on_complete
@@ -156,7 +153,7 @@ module NewRelic
               end
             end
           end
-    
+
           # Install a callback that will fire on failures
           # NOTE:  on_failure is not always called, so we're not always
           # unhooking the callback.  No harm/no foul in production, but
@@ -177,10 +174,10 @@ module NewRelic
                 original_callback.call(failed_request, error) if original_callback
                 remove_failure_callback(failed_request)
               end
-              request._nr_failure_instrumented = true 
+              request._nr_failure_instrumented = true
             end
           end
-    
+
           # on_failure callbacks cannot be removed in the on_complete
           # callback where this method is invoked because on_complete
           # fires before the on_failure!
@@ -189,20 +186,20 @@ module NewRelic
             request.on_header(&request._nr_original_on_header)
             request._nr_instrumented = false
           end
-    
-          # We execute customer's on_failure callback (if any) and 
-          # uninstall our hook here since the on_complete callback 
+
+          # We execute customer's on_failure callback (if any) and
+          # uninstall our hook here since the on_complete callback
           # fires before the on_failure callback.
           def remove_failure_callback(request)
             request.on_failure(&request._nr_original_on_failure)
             request._nr_failure_instrumented = false
           end
-    
+
           private
-    
+
           def first_request_is_serial?
             return false unless (first = self.requests.first)
-    
+
             # Before curb 0.9.8, requests was an array of Curl::Easy
             # instances.  Starting with 0.9.8, it's a Hash where the
             # values are Curl::Easy instances.
@@ -211,12 +208,11 @@ module NewRelic
             # We need to handle either case.
             #
             first = first[-1] if first.is_a?(Array)
-    
+
             first.respond_to?(:_nr_serial) && first._nr_serial
           end
-
         end
       end
     end
   end
-end
+end

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

@@ -5,8 +5,8 @@
 
 require_relative 'instrumentation'
 
-module NewRelic 
-  module Agent 
+module NewRelic
+  module Agent
     module Instrumentation
       module Curb
         module Easy
@@ -16,27 +16,27 @@ module NewRelic
             def http_head(*args, &blk)
               http_head_with_tracing { super }
             end
-      
+
             def http_post(*args, &blk)
               http_post_with_tracing { super }
             end
-      
+
             def http_put(*args, &blk)
               http_put_with_tracing { super }
             end
-      
+
             def http verb
               http_with_tracing(verb) { super }
             end
-      
+
             def perform
               perform_with_tracing { super }
             end
-      
+
             def method verb
-              method_with_tracing { super }
+              method_with_tracing(verb) { super }
             end
-      
+
             def header_str
               header_str_with_tracing { super }
             end
@@ -46,7 +46,7 @@ module NewRelic
         module Multi
           module Prepend
             include NewRelic::Agent::Instrumentation::Curb::Multi
-      
+
             def add(curl)
               add_with_tracing(curl) { super }
             end
@@ -54,7 +54,6 @@ module NewRelic
             def perform(&blk)
               perform_with_tracing { super }
             end
-      
           end
         end
       end