newrelic_rpm 6.6.0.358 → 6.11.0

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?

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.rb

@@ -42,7 +42,7 @@ DependencyDetection.defer do
   end
 
   def install_excon_instrumentation(excon_version)
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/excon_wrappers'
 
     if excon_version >= EXCON_MIDDLEWARE_MIN_VERSION

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/grape.rb

@@ -14,7 +14,6 @@ module NewRelic
         API_VERSION    = 'api.version'.freeze
         FORMAT_REGEX   = /\(\/?\.[\:\w]*\)/.freeze # either :format (< 0.12.0) or .ext (>= 0.12.0)
         VERSION_REGEX  = /:version(\/|$)/.freeze
-        EMPTY_STRING   = ''.freeze
         MIN_VERSION    = Gem::Version.new("0.2.0")
         PIPE_STRING    = '|'.freeze
 
@@ -33,7 +32,7 @@ module NewRelic
         end
 
         def name_for_transaction(route, class_name, version)
-          action_name = route.path.sub(FORMAT_REGEX, EMPTY_STRING)
+          action_name = route.path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
           method_name = route.request_method
           version ||= route.version
 
@@ -42,7 +41,7 @@ module NewRelic
           version = version.join(PIPE_STRING) if Array === version
 
           if version
-            action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
+            action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
             "#{class_name}-#{version}#{action_name} (#{method_name})"
           else
             "#{class_name}#{action_name} (#{method_name})"
@@ -50,12 +49,12 @@ module NewRelic
         end
 
         def name_for_transaction_deprecated(route, class_name, version)
-          action_name = route.route_path.sub(FORMAT_REGEX, EMPTY_STRING)
+          action_name = route.route_path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
           method_name = route.route_method
           version ||= route.route_version
 
           if version
-            action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
+            action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
             "#{class_name}-#{version}#{action_name} (#{method_name})"
           else
             "#{class_name}#{action_name} (#{method_name})"
@@ -118,11 +117,7 @@ DependencyDetection.defer do
 
     # Since 1.2.0, the class `Grape::API` no longer refers to an API instance, rather, what used to be `Grape::API` is `Grape::API::Instance`
     # https://github.com/ruby-grape/grape/blob/c20a73ac1e3f3ba1082005ed61bf69452373ba87/UPGRADING.md#upgrading-to--120
-    grape_api_class = if defined?(Grape::API::Instance)
-                        ::Grape::API::Instance
-                      else
-                        ::Grape::API
-                      end
+    grape_api_class = defined?(Grape::API::Instance) ? ::Grape::API::Instance : ::Grape::API
 
     grape_api_class.class_eval do
       def call_with_new_relic(env)

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

@@ -11,7 +11,7 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing http.rb instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/http_rb_wrappers'
   end
 
@@ -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

@@ -20,7 +20,7 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing HTTPClient instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/httpclient_wrappers'
   end
 
@@ -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

@@ -11,7 +11,7 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Net instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/net_http_wrappers'
   end
 
@@ -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