newrelic_rpm 6.9.0.363 → 6.10.0.364

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

@@ -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?

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

@@ -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/excon/connection.rb

@@ -4,8 +4,9 @@
 
 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

@@ -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/http.rb

@@ -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

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

@@ -38,12 +38,14 @@ DependencyDetection.defer do
           response = nil
           segment.add_request_headers wrapped_request
 
-          do_get_block_without_newrelic(req, proxy, conn, &block)
+          NewRelic::Agent::Tracer.capture_segment_error segment do
+            do_get_block_without_newrelic(req, proxy, conn, &block)
+          end
           response = conn.pop
           conn.push response
 
           wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPClientResponse.new(response)
-          segment.read_response_headers wrapped_response
+          segment.process_response_headers wrapped_response
 
           response
         ensure

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

@@ -46,7 +46,9 @@ module NewRelic
                   operation: method_name
                 )
                 begin
-                  send method_name_without, *args, &block
+                  NewRelic::Agent::Tracer.capture_segment_error segment do
+                    send method_name_without, *args, &block
+                  end
                 ensure
                   if NewRelic::Agent.config[:capture_memcache_keys]
                     segment.notice_nosql_statement "#{method_name} #{args.first.inspect}"

data/lib/new_relic/agent/instrumentation/memcache/dalli.rb

@@ -66,7 +66,9 @@ module NewRelic
                 ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, self)
 
                 begin
-                  send_multiget_without_newrelic_trace(keys)
+                  NewRelic::Agent::Tracer.capture_segment_error segment do                  
+                    send_multiget_without_newrelic_trace(keys)
+                  end
                 ensure
                   if ::NewRelic::Agent.config[:capture_memcache_keys]
                     segment.notice_nosql_statement "#{SEND_MULTIGET_METRIC_NAME} #{keys.inspect}"
@@ -87,7 +89,9 @@ module NewRelic
               define_method method_name do |*args, &block|
                 segment = NewRelic::Agent::Tracer.start_segment name: "Ruby/Memcached/Dalli/#{method_name}"
                 begin
-                  __send__ method_name_without, *args, &block
+                  NewRelic::Agent::Tracer.capture_segment_error segment do                  
+                    __send__ method_name_without, *args, &block
+                  end
                 ensure
                   segment.finish if segment
                 end

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

@@ -87,7 +87,9 @@ DependencyDetection.defer do
 
         begin
           result = NewRelic::Agent.disable_all_tracing do
-            instrument_without_new_relic_trace(name, payload, &block)
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              instrument_without_new_relic_trace(name, payload, &block)
+            end
           end
 
           new_relic_notice_statement(segment, payload, name) if segment
@@ -109,7 +111,9 @@ DependencyDetection.defer do
 
         begin
           result = NewRelic::Agent.disable_all_tracing do
-            save_without_new_relic_trace(doc, opts, &block)
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              save_without_new_relic_trace(doc, opts, &block)
+            end
           end
 
           new_relic_notice_statement(segment, doc, :save) if segment
@@ -131,7 +135,9 @@ DependencyDetection.defer do
 
         begin
           result = NewRelic::Agent.disable_all_tracing do
-            ensure_index_without_new_relic_trace(spec, opts, &block)
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              ensure_index_without_new_relic_trace(spec, opts, &block)
+            end
           end
 
           spec = case spec

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

@@ -19,10 +19,23 @@ module NewRelic
           end
         end
 
+        ERROR_KEYS = %w{ writeErrors writeConcernError writeConcernErrors }.freeze
+
+        def error_present?(event)
+          if reply = event.reply
+            ERROR_KEYS.detect{ |key| reply[key] }
+          end
+        end
+
         def completed(event)
           begin
             return unless NewRelic::Agent::Tracer.tracing_enabled?
             segment = segments.delete(event.operation_id)
+            if segment && (error_key = error_present?(event))
+              # taking the last error as there can potentially be many
+              attributes = event.reply[error_key][-1]
+              segment.notice_error Mongo::Error.new("%s (%s)" % [attributes["errmsg"], attributes["code"]])
+            end
             segment.finish if segment
           rescue Exception => e
             log_notification_error('completed', e)

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

@@ -33,10 +33,13 @@ DependencyDetection.defer do
           # RUBY-1244 Disable further tracing in request to avoid double
           # counting if connection wasn't started (which calls request again).
           NewRelic::Agent.disable_all_tracing do
-            response = request_without_newrelic_trace( request, *args, &block )
+            response = NewRelic::Agent::Tracer.capture_segment_error segment do
+              request_without_newrelic_trace(request, *args, &block)
+            end
           end
 
-          segment.read_response_headers response
+          wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
+          segment.process_response_headers wrapped_response
           response
         ensure
           segment.finish

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

@@ -8,6 +8,7 @@ module NewRelic
       class NotificationsSubscriber
         def initialize
           @queue_key = ['NewRelic', self.class.name, object_id].join('-')
+          define_exception_method
         end
 
         def self.subscribed?
@@ -22,7 +23,7 @@ module NewRelic
 
           notifier = ActiveSupport::Notifications.notifier
 
-          instance_variable_names.each do |name| 
+          instance_variable_names.each do |name|
             if notifier.instance_variable_defined?(name)
               subscribers = notifier.instance_variable_get(name)
               if subscribers.is_a? Array
@@ -69,6 +70,29 @@ module NewRelic
         def state
           NewRelic::Agent::Tracer.state
         end
+
+        def define_exception_method
+          # we don't expect this to be called more than once, but we're being
+          # defensive.
+          return if defined?(exception_object)
+          return unless defined?(::ActiveSupport)
+          if ::ActiveSupport::VERSION::STRING < "5.0.0"
+            # Earlier versions of Rails did not add the exception itself to the
+            # payload asssessible via :exception_object, so we create a stand-in
+            # error object from the given class name and message.
+            # NOTE: no backtrace available this way, but we can notice the error
+            # well enough to send the necessary info the UI requires to present it.
+            def exception_object(payload)
+              exception_class, message = payload[:exception]
+              return nil unless exception_class
+              NewRelic::Agent::NoticibleError.new exception_class, message
+            end
+          else
+            def exception_object(payload)
+              payload[:exception_object]
+            end
+          end
+        end
       end
 
     end

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

@@ -71,7 +71,9 @@ DependencyDetection.defer do
         )
         begin
           segment.notice_nosql_statement(statement) if statement
-          call_without_new_relic(*args, &block)
+          NewRelic::Agent::Tracer.capture_segment_error segment do
+            call_without_new_relic(*args, &block)
+          end
         ensure
           segment.finish if segment
         end
@@ -96,7 +98,9 @@ DependencyDetection.defer do
         )
         begin
           segment.notice_nosql_statement(statement)
-          call_pipeline_without_new_relic(*args, &block)
+          NewRelic::Agent::Tracer.capture_segment_error segment do
+            call_pipeline_without_new_relic(*args, &block)
+          end
         ensure
           segment.finish if segment
         end
@@ -117,7 +121,9 @@ DependencyDetection.defer do
         )
 
         begin
-          connect_without_new_relic(*args, &block)
+          NewRelic::Agent::Tracer.capture_segment_error segment do
+            connect_without_new_relic(*args, &block)
+          end
         ensure
           segment.finish if segment
         end

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

@@ -1,4 +1,3 @@
-# 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.
 

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

@@ -60,10 +60,10 @@ module NewRelic
     module Instrumentation
       module TyphoeusTracing
 
-        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")
-
         def self.is_supported_version?
           Gem::Version.new(Typhoeus::VERSION) >= NewRelic::Agent::Instrumentation::TyphoeusTracing::EARLIEST_VERSION
         end
@@ -72,6 +72,17 @@ module NewRelic
           request.respond_to?(:hydra) && request.hydra
         end
 
+        def self.response_message(response)
+          if response.respond_to?(:response_message)
+            response.response_message
+          elsif response.respond_to?(:return_message)
+            response.return_message
+          else
+            # 0.5.4 seems to have lost xxxx_message methods altogether.
+            "timeout" 
+          end
+        end
+
         def self.trace(request)
           state = NewRelic::Agent::Tracer.state
           return unless state.is_execution_traced?
@@ -92,8 +103,14 @@ module NewRelic
           segment.add_request_headers wrapped_request
 
           callback = Proc.new do
-            wrapped_response = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPResponse.new(request.response)
-            segment.read_response_headers wrapped_response
+            wrapped_response = HTTPClients::TyphoeusHTTPResponse.new(request.response)
+
+            segment.process_response_headers wrapped_response
+
+            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)