newrelic_rpm 6.6.0.358 → 6.11.0.365

data/lib/new_relic/agent/http_clients/httpclient_wrappers.rb

@@ -1,21 +1,17 @@
 # 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.
+# frozen_string_literal: true
 
-require 'new_relic/agent/http_clients/abstract_request'
+require_relative 'abstract'
 
 module NewRelic
   module Agent
     module HTTPClients
-      class HTTPClientResponse
-        attr_reader :response
-
-        def initialize(response)
-          @response = response
-        end
+      class HTTPClientResponse < AbstractResponse
 
         def [](key)
-          response.headers.each do |k,v|
+          @wrapped_response.headers.each do |k,v|
             if key.downcase == k.downcase
               return v
             end
@@ -24,12 +20,12 @@ module NewRelic
         end
 
         def to_hash
-          response.headers
+          @wrapped_response.headers
         end
       end
 
       class HTTPClientRequest < AbstractRequest
-        attr_reader :request, :uri
+        attr_reader :request
 
         HTTP_CLIENT = "HTTPClient".freeze
         LHOST = 'host'.freeze
@@ -38,7 +34,6 @@ module NewRelic
 
         def initialize(request)
           @request = request
-          @uri = request.header.request_uri
         end
 
         def type
@@ -59,6 +54,10 @@ module NewRelic
           host_from_header || uri.host.to_s
         end
 
+        def uri
+          @uri ||= URIUtil.parse_and_normalize_url(request.header.request_uri)
+        end
+
         def [](key)
           request.headers[key]
         end

data/lib/new_relic/agent/http_clients/net_http_wrappers.rb

@@ -1,26 +1,38 @@
 # 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.
+# frozen_string_literal: true
 
-require 'new_relic/agent/http_clients/abstract_request'
+require_relative 'abstract'
 
 module NewRelic
   module Agent
     module HTTPClients
+      class NetHTTPResponse < AbstractResponse
+
+        def [](key)
+          @wrapped_response[key]
+        end
+
+        def to_hash
+          @wrapped_response.to_hash
+        end
+      end
+
       class NetHTTPRequest < AbstractRequest
         def initialize(connection, request)
           @connection = connection
           @request = request
         end
 
-        NET_HTTP = 'Net::HTTP'.freeze
+        NET_HTTP = 'Net::HTTP'
 
         def type
           NET_HTTP
         end
 
-        HOST = 'host'.freeze
-        COLON = ':'.freeze
+        HOST = 'host'
+        COLON = ':'
 
         def host_from_header
           if hostname = self[HOST]

data/lib/new_relic/agent/http_clients/typhoeus_wrappers.rb

@@ -1,16 +1,14 @@
 # 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.
+# frozen_string_literal: true
 
-require 'new_relic/agent/http_clients/abstract_request'
+require_relative 'abstract'
 
 module NewRelic
   module Agent
     module HTTPClients
-      class TyphoeusHTTPResponse
-        def initialize(response)
-          @response = response
-        end
+      class TyphoeusHTTPResponse < AbstractResponse
 
         def [](key)
           unless headers.nil?
@@ -33,7 +31,7 @@ module NewRelic
         private
 
         def headers
-          @response.headers
+          @wrapped_response.headers
         end
       end
 

data/lib/new_relic/agent/http_clients/uri_util.rb

@@ -2,6 +2,7 @@
 # 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.
+# frozen_string_literal: true
 
 # This module includes utilities for manipulating URIs, particularly from the
 # context of Net::HTTP requests. We don't always have direct access to the full
@@ -41,10 +42,10 @@ module NewRelic
           uri
         end
 
-        QUESTION_MARK = "?".freeze
+        QUESTION_MARK = "?"
 
         def self.strip_query_string(fragment)
-          if(fragment.include?(QUESTION_MARK))
+          if fragment.include? QUESTION_MARK
             fragment.split(QUESTION_MARK).first
           else
             fragment

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

@@ -29,7 +29,10 @@ module NewRelic
         def finish(name, id, payload) #THREAD_LOCAL_ACCESS
           return unless state.is_execution_traced?
 
-          notice_error payload if payload.key? :exception
+          if exception = exception_object(payload)
+            NewRelic::Agent.notice_error exception
+          end
+
           finishable = pop_segment(id)
           finishable.finish if finishable
         rescue => e
@@ -47,14 +50,9 @@ module NewRelic
         end
 
         DOT_ACTION_CABLE = '.action_cable'.freeze
-        EMPTY_STRING = ''.freeze
 
         def action_name(name)
-          name.gsub DOT_ACTION_CABLE, EMPTY_STRING
-        end
-
-        def notice_error(payload)
-          NewRelic::Agent.notice_error payload[:exception_object]
+          name.gsub DOT_ACTION_CABLE, NewRelic::EMPTY_STR
         end
       end
     end

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

@@ -35,6 +35,10 @@ module NewRelic
           if state.is_execution_traced? \
               && !should_ignore(payload, controller_class(payload))
 
+            if exception = exception_object(payload)
+              finishable.notice_error(exception)
+            end
+
             finishable.finish
           else
             Agent.instance.pop_trace_execution_flag

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

@@ -24,8 +24,13 @@ module NewRelic
         end
 
         def finish(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = pop_segment(id)
-          event.finish if event
+          if segment = pop_segment(id)
+
+          if exception = exception_object(payload)
+            segment.notice_error exception
+          end
+            segment.finish
+          end
         rescue => e
           log_notification_error(e, name, 'finish')
         end
@@ -97,6 +102,10 @@ module NewRelic
         def finish
           @finishable.finish if @finishable
         end
+
+        def notice_error error
+          @finishable.notice_error error if @finishable
+        end
       end
     end
 

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

@@ -43,7 +43,7 @@ module NewRelic
           end
         end
 
-        def log_with_newrelic_instrumentation(*args, &block) #THREAD_LOCAL_ACCESS
+        def log_with_newrelic_instrumentation(*args, &block)
           state = NewRelic::Agent::Tracer.state
 
           if !state.is_execution_traced?
@@ -78,7 +78,9 @@ module NewRelic
           segment._notice_sql(sql, @config, EXPLAINER)
 
           begin
-            log_without_newrelic_instrumentation(*args, &block)
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              log_without_newrelic_instrumentation(*args, &block)
+            end
           ensure
             segment.finish if segment
           end

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

@@ -58,8 +58,13 @@ module NewRelic
           return if cached?(payload)
           return unless state.is_execution_traced?
 
-          segment = pop_segment(id)
-          segment.finish if segment
+          if segment = pop_segment(id)
+            if exception = exception_object(payload)
+              segment.notice_error(exception)
+            end
+            segment.finish
+          end
+
         rescue => e
           log_notification_error(e, name, 'finish')
         end

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

@@ -16,7 +16,7 @@ module NewRelic
 
         def finish name, id, payload
           return unless state.is_execution_traced?
-          finish_segment id
+          finish_segment id, payload
         rescue => e
           log_notification_error e, name, 'finish'
         end
@@ -28,9 +28,13 @@ module NewRelic
           push_segment id, segment
         end
 
-        def finish_segment id
-          segment = pop_segment id
-          segment.finish if segment
+        def finish_segment id, payload
+          if segment = pop_segment(id)
+            if exception = exception_object(payload)
+              segment.notice_error(exception)
+            end
+            segment.finish
+          end
         end
 
         def metric_name name, payload

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

@@ -1,6 +1,7 @@
 # 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.
+# frozen_string_literal: true
 
 DependencyDetection.defer do
   named :bunny
@@ -11,7 +12,7 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Bunny instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/messaging'
     require 'new_relic/agent/transaction/message_broker_segment'
   end
@@ -41,10 +42,11 @@ DependencyDetection.defer do
             )
           rescue => e
             NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Exchange#publish", e
-          end
-
-          begin
             publish_without_new_relic payload, opts
+          else
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              publish_without_new_relic payload, opts
+            end
           ensure
             segment.finish if segment
           end
@@ -55,28 +57,40 @@ DependencyDetection.defer do
         alias_method :pop_without_new_relic, :pop
 
         def pop(opts = {:manual_ack => false}, &block)
-          t0 = Time.now
-          msg = pop_without_new_relic opts, &block
-          delivery_info, message_properties, _payload = msg
+          bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
+          begin
+            t0 = Time.now
+            msg = pop_without_new_relic opts, &block
+            delivery_info, message_properties, _payload = msg
+          rescue StandardError => error
+            bunny_error = error
+          end
 
           begin
-            if delivery_info
-              exchange_name = NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange)
-              exchange_type = NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel)
-
-              segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
-                library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-                destination_name: exchange_name,
-                delivery_info: delivery_info,
-                message_properties: message_properties,
-                exchange_type: exchange_type,
-                queue_name: name,
-                start_time: t0
-              )
+            exchange_name, exchange_type = if delivery_info
+              [ NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange),
+                NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel) ]
+            else
+              [ NewRelic::Agent::Instrumentation::Bunny.exchange_name(NewRelic::EMPTY_STR),
+                NewRelic::Agent::Instrumentation::Bunny.exchange_type({}, channel) ]
             end
 
+            segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
+              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+              destination_name: exchange_name,
+              delivery_info: (delivery_info || {}),
+              message_properties: (message_properties || {headers: {}}),
+              exchange_type: exchange_type,
+              queue_name: name,
+              start_time: t0
+            )
           rescue => e
             NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#pop", e
+          else
+            if bunny_error
+              segment.notice_error bunny_error
+              raise bunny_error
+            end
           ensure
             segment.finish if segment
           end
@@ -97,10 +111,11 @@ DependencyDetection.defer do
             )
           rescue => e
             NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#purge", e
-          end
-
-          begin
             purge_without_new_relic(*args)
+          else
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              purge_without_new_relic(*args)
+            end
           ensure
             segment.finish if segment
           end
@@ -134,18 +149,20 @@ module NewRelic
   module Agent
     module Instrumentation
       module Bunny
-        LIBRARY = 'RabbitMQ'.freeze
-        DEFAULT = 'Default'.freeze
-        SLASH   = '/'.freeze
+        LIBRARY = 'RabbitMQ'
+        DEFAULT_NAME = 'Default'
+        DEFAULT_TYPE = :direct
+
+        SLASH   = '/'
 
         class << self
           def exchange_name name
-            name.empty? ? DEFAULT : name
+            name.empty? ? DEFAULT_NAME : name
           end
 
           def exchange_type delivery_info, channel
             if di_exchange = delivery_info[:exchange]
-              return :direct if di_exchange.empty?
+              return DEFAULT_TYPE if di_exchange.empty?
               return channel.exchanges[delivery_info[:exchange]].type if channel.exchanges[di_exchange]
             end
           end

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

@@ -14,7 +14,7 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Curb instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/curb_wrappers'
   end
 
@@ -22,10 +22,12 @@ 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
@@ -53,7 +55,7 @@ DependencyDetection.defer do
 
 
       # 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 +74,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 +103,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 +127,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 +140,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 +153,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 +194,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?