newrelic_rpm 6.9.0.363 → 6.12.0.367

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

@@ -1,6 +1,6 @@
 # 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.
 
 require 'new_relic/agent/transaction'
 require 'new_relic/agent/instrumentation/queue_time'

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

@@ -1,6 +1,6 @@
 # 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.
 
 DependencyDetection.defer do
   named :curb
@@ -22,38 +22,64 @@ DependencyDetection.defer do
     class Curl::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
 
       # We have to hook these three methods separately, as they don't use
       # Curl::Easy#http
-      def http_head_with_newrelic(*args, &blk)
-        self._nr_http_verb = :HEAD
-        http_head_without_newrelic(*args, &blk)
+      if RUBY_VERSION < "2.7.0"
+        def http_head_with_newrelic(*args, &blk)
+          self._nr_http_verb = :HEAD
+          http_head_without_newrelic(*args, &blk)
+        end
+      else
+        def http_head_with_newrelic(*args, **kwargs, &blk)
+          self._nr_http_verb = :HEAD
+          http_head_without_newrelic(*args, **kwargs, &blk)
+        end
       end
+
       alias_method :http_head_without_newrelic, :http_head
       alias_method :http_head, :http_head_with_newrelic
 
-      def http_post_with_newrelic(*args, &blk)
-        self._nr_http_verb = :POST
-        http_post_without_newrelic(*args, &blk)
+      if RUBY_VERSION < "2.7.0"
+        def http_post_with_newrelic(*args, &blk)
+          self._nr_http_verb = :POST
+          http_post_without_newrelic(*args, &blk)
+        end
+      else
+        def http_post_with_newrelic(*args, **kwargs, &blk)
+          self._nr_http_verb = :POST
+          http_post_without_newrelic(*args, **kwargs, &blk)
+        end
       end
+
       alias_method :http_post_without_newrelic, :http_post
       alias_method :http_post, :http_post_with_newrelic
 
-      def http_put_with_newrelic(*args, &blk)
-        self._nr_http_verb = :PUT
-        http_put_without_newrelic(*args, &blk)
+      if RUBY_VERSION < "2.7.0"
+        def http_put_with_newrelic(*args, &blk)
+          self._nr_http_verb = :PUT
+          http_put_without_newrelic(*args, &blk)
+        end
+      else
+        def http_put_with_newrelic(*args, **kwargs, &blk)
+          self._nr_http_verb = :PUT
+          http_put_without_newrelic(*args, **kwargs, &blk)
+        end
       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 )
+      def http_with_newrelic verb
         self._nr_http_verb = verb.to_s.upcase
         http_without_newrelic( verb )
       end
@@ -72,9 +98,9 @@ DependencyDetection.defer do
       alias_method :perform, :perform_with_newrelic
 
       # Record the HTTP verb for future #perform calls
-      def method_with_newrelic(m)
-        self._nr_http_verb = m.upcase
-        method_without_newrelic(m)
+      def method_with_newrelic verb
+        self._nr_http_verb = verb.upcase
+        method_without_newrelic(verb)
       end
 
       alias_method :method_without_newrelic, :method
@@ -101,12 +127,12 @@ DependencyDetection.defer do
       include NewRelic::Agent::MethodTracer
 
       # Add CAT with callbacks if the request is serial
-      def add_with_newrelic(curl) #THREAD_LOCAL_ACCESS
+      def add_with_newrelic(curl)
         if curl.respond_to?(:_nr_serial) && curl._nr_serial
           hook_pending_request(curl) if NewRelic::Agent::Tracer.tracing_enabled?
         end
 
-        return add_without_newrelic( curl )
+        return add_without_newrelic curl
       end
 
       alias_method :add_without_newrelic, :add
@@ -125,9 +151,9 @@ DependencyDetection.defer do
       alias_method :perform, :perform_with_newrelic
 
 
-      # Instrument the specified +request+ (a Curl::Easy object) and set up cross-application
-      # tracing if it's enabled.
-      def hook_pending_request(request) #THREAD_LOCAL_ACCESS
+      # Instrument the specified +request+ (a Curl::Easy object)
+      # 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(
@@ -138,9 +164,11 @@ DependencyDetection.defer do
 
         segment.add_request_headers wrapped_request
 
+        # install all callbacks
         unless request._nr_instrumented
           install_header_callback(request, wrapped_response)
           install_completion_callback(request, wrapped_response, segment)
+          install_failure_callback(request, wrapped_response, segment)
           request._nr_instrumented = true
         end
       rescue => err
@@ -149,35 +177,37 @@ DependencyDetection.defer do
 
 
       # 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
+      # during the life-cycle of external request
       def wrap_request(request)
         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 )
+      # Install a callback that will record the response headers
+      # to enable CAT linking
+      def install_header_callback(request, wrapped_response)
         original_callback = request.on_header
         request._nr_original_on_header = original_callback
         request._nr_header_str = nil
         request.on_header do |header_data|
           if original_callback
-            original_callback.call( header_data )
+            original_callback.call header_data
           else
-            wrapped_response.append_header_data( header_data )
+            wrapped_response.append_header_data header_data
             header_data.length
           end
         end
       end
 
       # Install a callback that will finish the trace.
-      def install_completion_callback(request, wrapped_response, segment) #THREAD_LOCAL_ACCESS
+      def install_completion_callback(request, wrapped_response, segment)
         original_callback = request.on_complete
         request._nr_original_on_complete = original_callback
         request.on_complete do |finished_request|
           begin
-            segment.read_response_headers wrapped_response
+            segment.process_response_headers wrapped_response
           ensure
             segment.finish if segment
             # Make sure the existing completion callback is run, and restore the
@@ -188,12 +218,47 @@ DependencyDetection.defer do
         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
+      # definitely something to beware of if debugging callback issues
+      # _nr_failure_instrumented exists to prevent infinitely chaining
+      # our on_failure callback hook.
+      def install_failure_callback(request, wrapped_response, segment)
+        return if request._nr_failure_instrumented
+        original_callback = request.on_failure
+        request._nr_original_on_failure = original_callback
+        request.on_failure do |failed_request, error|
+          begin
+            if segment
+              noticible_error = NewRelic::Agent::NoticibleError.new error[0].name, error[-1]
+              segment.notice_error noticible_error
+            end
+          ensure
+            original_callback.call(failed_request, error) if original_callback
+            remove_failure_callback(failed_request)
+          end
+          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!
       def remove_instrumentation_callbacks(request)
         request.on_complete(&request._nr_original_on_complete)
         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 
+      # 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?

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

@@ -1,6 +1,6 @@
 # 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.
 
 DependencyDetection.defer do
   named :data_mapper
@@ -140,7 +140,9 @@ module NewRelic
             )
 
             begin
-              self.send("#{method_name}_without_newrelic", *args, &blk)
+              NewRelic::Agent::Tracer.capture_segment_error segment do
+                self.send("#{method_name}_without_newrelic", *args, &blk)
+              end
             rescue ::DataObjects::ConnectionError => e
               raise
             rescue ::DataObjects::SQLError => e

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

@@ -1,6 +1,6 @@
 # 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.
 
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -89,22 +89,44 @@ DependencyDetection.defer do
 
   executes do
     Delayed::Worker.class_eval do
-      def initialize_with_new_relic(*args)
-        initialize_without_new_relic(*args)
-        worker_name = case
-                      when self.respond_to?(:name) then self.name
-                      when self.class.respond_to?(:default_name) then self.class.default_name
-                      end
-        NewRelic::DelayedJobInjection.worker_name = worker_name
-
-        if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
-          !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic) )
-
-          ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
-          install_newrelic_job_tracer
-          NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job
-        else
-          NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
+
+      if RUBY_VERSION < "2.7.0"
+        def initialize_with_new_relic(*args)
+          initialize_without_new_relic(*args)
+          worker_name = case
+                        when self.respond_to?(:name) then self.name
+                        when self.class.respond_to?(:default_name) then self.class.default_name
+                        end
+          NewRelic::DelayedJobInjection.worker_name = worker_name
+  
+          if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
+            !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic) )
+  
+            ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
+            install_newrelic_job_tracer
+            NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job
+          else
+            NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
+          end
+        end
+      else
+        def initialize_with_new_relic(*args, **kwargs)
+          initialize_without_new_relic(*args, **kwargs)
+          worker_name = case
+                        when self.respond_to?(:name) then self.name
+                        when self.class.respond_to?(:default_name) then self.class.default_name
+                        end
+          NewRelic::DelayedJobInjection.worker_name = worker_name
+
+          if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
+            !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic) )
+
+            ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
+            install_newrelic_job_tracer
+            NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job
+          else
+            NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
+          end
         end
       end
 
@@ -119,16 +141,30 @@ DependencyDetection.defer do
 
           alias_method :invoke_job_without_new_relic, :invoke_job
 
-          def invoke_job(*args, &block)
-            options = {
-              :category => NR_TRANSACTION_CATEGORY,
-              :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)
-            }
-
-            perform_action_with_newrelic_trace(options) do
-              invoke_job_without_new_relic(*args, &block)
+          if RUBY_VERSION < "2.7.0"
+            def invoke_job(*args, &block)
+              options = {
+                :category => NR_TRANSACTION_CATEGORY,
+                :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)
+              }
+  
+              perform_action_with_newrelic_trace(options) do
+                invoke_job_without_new_relic(*args, &block)
+              end
+            end
+          else
+            def invoke_job(*args, **kwargs, &block)
+              options = {
+                :category => NR_TRANSACTION_CATEGORY,
+                :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)
+              }
+  
+              perform_action_with_newrelic_trace(options) do
+                invoke_job_without_new_relic(*args, **kwargs, &block)
+              end
             end
           end
+
         end
       end
     end

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

@@ -1,6 +1,6 @@
 # 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.
 
 DependencyDetection.defer do
   named :excon

data/lib/new_relic/agent/instrumentation/excon/connection.rb

@@ -1,11 +1,12 @@
 # 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.
 
 module ::Excon
   class Connection
+    # @connection is deprecated in newer excon versions and replaced with @data
     def newrelic_connection_params
-      (@connection || @data)
+      (@data || @connection)
     end
 
     def newrelic_resolved_request_params(request_params)
@@ -27,10 +28,12 @@ module ::Excon
         response = nil
         segment.add_request_headers wrapped_request
 
-        response = request_without_newrelic_trace(resolved_params, &block)
+        response = NewRelic::Agent::Tracer.capture_segment_error segment do
+          request_without_newrelic_trace(resolved_params, &block)
+        end
 
         wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(response)
-        segment.read_response_headers wrapped_response
+        segment.process_response_headers wrapped_response
 
         response
       ensure

data/lib/new_relic/agent/instrumentation/excon/middleware.rb

@@ -1,6 +1,6 @@
 # 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.
 
 module ::Excon
   module Middleware
@@ -49,11 +49,12 @@ module ::Excon
         segment = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
         if segment
           begin
+            segment.notice_error(datum[:error]) if datum[:error]
             datum[:connection].instance_variable_set(TRACE_DATA_IVAR, nil)
 
             if datum[:response]
               wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(datum[:response])
-              segment.read_response_headers wrapped_response
+              segment.process_response_headers wrapped_response
             end
           ensure
             segment.finish if segment

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

@@ -1,6 +1,6 @@
 # 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.
 
 require 'new_relic/agent/parameter_filtering'
 

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

@@ -1,6 +1,6 @@
 # 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.
 
 DependencyDetection.defer do
   named :httprb
@@ -29,9 +29,12 @@ DependencyDetection.defer do
 
           segment.add_request_headers wrapped_request
 
-          response = perform_without_newrelic_trace(request, options)
+          response = NewRelic::Agent::Tracer.capture_segment_error segment do
+            perform_without_newrelic_trace(request, options)
+          end
+
           wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPResponse.new response
-          segment.read_response_headers wrapped_response
+          segment.process_response_headers wrapped_response
 
           response
         ensure