wd_newrelic_rpm 3.5.6 → 3.5.8

data/lib/new_relic/agent/cross_app_tracing.rb

@@ -0,0 +1,281 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+module NewRelic
+  module Agent
+    module CrossAppTracing
+      extend NewRelic::Agent::CrossAppMonitor::EncodingFunctions
+
+      # Exception raised if there is a problem with cross app transactions.
+      class Error < RuntimeError; end
+
+
+      # The cross app response header for "outgoing" calls
+      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'
+
+      # The cross app id header for "outgoing" calls
+      NR_ID_HEADER = 'X-NewRelic-ID'
+
+      # The cross app transaction header for "outgoing" calls
+      NR_TXN_HEADER = 'X-NewRelic-Transaction'
+
+      # The index of the transaction GUID in the appdata header of responses
+      APPDATA_TXN_GUID_INDEX = 5
+
+
+      ###############
+      module_function
+      ###############
+
+      # Send the given +request+, adding metrics appropriate to the
+      # response when it comes back.
+      def trace_http_request( http, request )
+        return yield unless NewRelic::Agent.is_execution_traced?
+
+        t0, segment = start_trace( http, request )
+        begin
+          response = yield
+        ensure
+          finish_trace( t0, segment, request, response, http ) if t0
+        end
+
+        return response
+      end
+
+
+      # Set up the necessary state for cross-application tracing before the
+      # given +request+ goes out on the specified +http+ connection.
+      def start_trace( http, request )
+        inject_request_headers( request ) if cross_app_enabled?
+
+        # Create a segment and time the call
+        t0 = Time.now
+        segment = stats_engine.push_scope( "External/#{http.address}/all", t0 )
+
+        return t0, segment
+      rescue => err
+        NewRelic::Agent.logger.error "Uncaught exception while tracing HTTP request", err
+        return nil
+      end
+
+
+      # Finish tracing the HTTP +request+ that started at +t0+ with the information in
+      # +response+ and the given +http+ connection.
+      def finish_trace( t0, segment, request, response, http )
+        t1 = Time.now
+        duration = t1.to_f - t0.to_f
+
+        begin
+          if request && response && http
+            # Figure out which metrics we need to report based on the request and response
+            # The last (most-specific) one is scoped.
+            metrics = metrics_for( http, request, response )
+            scoped_metric = metrics.pop
+
+            # Report the metrics
+            metrics.each { |metric| get_metric(metric).trace_call(duration) }
+            get_scoped_metric( scoped_metric ).trace_call( duration )
+
+            # Add TT custom parameters
+            stats_engine.rename_scope_segment( scoped_metric )
+            extract_custom_parameters( response ) if response_is_crossapp?( response )
+          end
+        ensure
+          # We always need to pop the scope stack to avoid an inconsistent
+          # state, which will prevent tracing of the whole transaction.
+          stats_engine.pop_scope( segment, duration, t1 )
+        end
+      rescue NewRelic::Agent::CrossAppTracing::Error => err
+        NewRelic::Agent.logger.debug "while cross app tracing", err
+      rescue => err
+        NewRelic::Agent.logger.error "Uncaught exception while finishing an HTTP request trace", err
+      end
+
+
+      # Return +true+ if cross app tracing is enabled in the config.
+      def cross_app_enabled?
+        NewRelic::Agent.config[:cross_process_id] &&
+          (NewRelic::Agent.config[:"cross_application_tracer.enabled"] ||
+           NewRelic::Agent.config[:cross_application_tracing])
+      end
+
+
+      # Memoized fetcher for the cross app encoding key. Raises a
+      # NewRelic::Agent::CrossAppTracing::Error if the key isn't configured.
+      def cross_app_encoding_key
+        NewRelic::Agent.config[:encoding_key] or
+          raise NewRelic::Agent::CrossAppTracing::Error, "No encoding_key set."
+      end
+
+
+      # Inject the X-Process header into the outgoing +request+.
+      def inject_request_headers( request )
+        key = cross_app_encoding_key()
+        cross_app_id = NewRelic::Agent.config[:cross_process_id] or
+          raise NewRelic::Agent::CrossAppTracing::Error, "no cross app ID configured"
+        txn_guid = NewRelic::Agent::TransactionInfo.get.guid
+        txn_data = NewRelic.json_dump([ txn_guid, false ])
+
+        request[ NR_ID_HEADER ] = obfuscate_with_key( key, cross_app_id )
+        request[ NR_TXN_HEADER ] = obfuscate_with_key( key, txn_data )
+
+      rescue NewRelic::Agent::CrossAppTracing::Error => err
+        NewRelic::Agent.logger.debug "Not injecting x-process header", err
+      end
+
+
+      # Extract any custom parameters from +response+ if it's cross-application and
+      # add them to the current TT node.
+      def extract_custom_parameters( response )
+
+        appdata = extract_appdata( response )
+        sampler = NewRelic::Agent.instance.transaction_sampler
+        sampler.add_segment_parameters( :transaction_guid => appdata[APPDATA_TXN_GUID_INDEX] )
+
+      end
+
+
+      # Return the set of metrics (NewRelic::MethodTraceStats objects) that correspond to
+      # the given +request+ and +response+.
+      def metrics_for( http, request, response )
+        metrics = common_metrics( http )
+
+        if response_is_crossapp?( response )
+          begin
+            metrics.concat metrics_for_crossapp_response( http, response )
+          rescue => err
+            # Fall back to regular metrics if there's a problem with x-process metrics
+            NewRelic::Agent.logger.debug "%p while fetching x-process metrics: %s" %
+              [ err.class, err.message ]
+            metrics.concat metrics_for_regular_response( http, request, response )
+          end
+        else
+          NewRelic::Agent.logger.debug "Response doesn't have CAT headers."
+          metrics.concat metrics_for_regular_response( http, request, response )
+        end
+
+        return metrics
+      end
+
+
+      # Return an Array of metrics used for every response.
+      def common_metrics( http )
+        metrics = [ "External/all" ]
+        metrics << "External/#{http.address}/all"
+
+        if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+          metrics << "External/allWeb"
+        else
+          metrics << "External/allOther"
+        end
+
+        return metrics
+      end
+
+
+      # Returns +true+ if Cross Application Tracing is enabled, and the given +response+
+      # has the appropriate headers.
+      def response_is_crossapp?( response )
+        return false unless cross_app_enabled?
+        unless response[NR_APPDATA_HEADER]
+          NewRelic::Agent.logger.debug "Response doesn't have the %p header: %p" %
+            [ NR_APPDATA_HEADER, response.to_hash ]
+          return false
+        end
+
+        return true
+      end
+
+
+      # Return the set of metric objects appropriate for the given cross app
+      # +response+.
+      def metrics_for_crossapp_response( http, response )
+        xp_id, txn_name, q_time, r_time, req_len, _ = extract_appdata( response )
+
+        check_crossapp_id( xp_id )
+        check_transaction_name( txn_name )
+
+        NewRelic::Agent.logger.debug "CAT xp_id: %p, txn_name: %p." % [ xp_id, txn_name ]
+
+        metrics = []
+        metrics << "ExternalApp/#{http.address}/#{xp_id}/all"
+        metrics << "ExternalTransaction/#{http.address}/#{xp_id}/#{txn_name}"
+
+        return metrics
+      end
+
+
+      # Extract x-process application data from the specified +response+ and return
+      # it as an array of the form:
+      #
+      #  [
+      #    <cross app ID>,
+      #    <transaction name>,
+      #    <queue time in seconds>,
+      #    <response time in seconds>,
+      #    <request content length in bytes>,
+      #    <transaction GUID>
+      #  ]
+      def extract_appdata( response )
+        appdata = response[NR_APPDATA_HEADER] or
+          raise NewRelic::Agent::CrossAppTracing::Error,
+            "Can't derive metrics for response: no #{NR_APPDATA_HEADER} header!"
+
+        key = cross_app_encoding_key()
+        decoded_appdata = decode_with_key( key, appdata )
+        decoded_appdata.set_encoding( ::Encoding::UTF_8 ) if
+          decoded_appdata.respond_to?( :set_encoding )
+
+        return NewRelic.json_load( decoded_appdata )
+      end
+
+
+      # Return the set of metric objects appropriate for the given (non-cross app)
+      # +response+.
+      def metrics_for_regular_response( http, request, response )
+        metrics = []
+        metrics << "External/#{http.address}/Net::HTTP/#{request.method}"
+
+        return metrics
+      end
+
+
+      # Convenience function for fetching the metric associated with +metric_name+.
+      def get_metric( metric_name )
+        stats_engine.get_stats_no_scope( metric_name )
+      end
+
+
+      # Convenience function for fetching the scoped metric associated with +metric_name+.
+      def get_scoped_metric( metric_name )
+        # Default is to use the metric_name itself as the scope, which is what we want
+        stats_engine.get_stats( metric_name )
+      end
+
+
+      # Fetch a reference to the stats engine.
+      def stats_engine
+        NewRelic::Agent.instance.stats_engine
+      end
+
+
+      # Check the given +id+ to ensure it conforms to the format of a cross-application
+      # ID. Raises an NewRelic::Agent::CrossAppTracing::Error if it doesn't.
+      def check_crossapp_id( id )
+        id =~ /\A\d+#\d+\z/ or
+          raise NewRelic::Agent::CrossAppTracing::Error,
+            "malformed cross application ID %p" % [ id ]
+      end
+
+
+      # Check the given +name+ to ensure it conforms to the format of a valid transaction
+      # name.
+      def check_transaction_name( name )
+        # No-op -- apparently absolutely anything is a valid transaction name?
+        # This is here for when that inevitably comes back to haunt us.
+      end
+
+    end
+  end
+end
+

data/lib/new_relic/agent/database.rb

@@ -62,20 +62,30 @@ module NewRelic
       def explain_sql(sql, connection_config)
         return nil unless sql && connection_config
         statement = sql.split(";\n")[0] # only explain the first
-        explain_sql = explain_statement(statement, connection_config)
-        return explain_sql || []
+        explain_plan = explain_statement(statement, connection_config)
+        return explain_plan || []
       end
 
       def explain_statement(statement, config)
-        if is_select?(statement)
-          handle_exception_in_explain do
-            connection = get_connection(config)
-            plan = nil
-            if connection
-              plan = process_resultset(connection.execute("EXPLAIN #{statement}"))
-            end
-            return plan
+        return unless is_select?(statement)
+
+        if statement[-3,3] == '...'
+          NewRelic::Agent.logger.debug('Unable to collect explain plan for truncated query.')
+          return
+        end
+
+        if parameterized?(statement)
+          NewRelic::Agent.logger.debug('Unable to collect explain plan for parameterized query.')
+          return
+        end
+
+        handle_exception_in_explain do
+          connection = get_connection(config)
+          plan = nil
+          if connection
+            plan = process_resultset(connection.execute("EXPLAIN #{statement}"))
           end
+          return plan
         end
       end
 
@@ -126,6 +136,10 @@ module NewRelic
         (first_word.upcase == 'SELECT')
       end
 
+      def parameterized?(statement)
+        Obfuscator.instance.obfuscate_single_quote_literals(statement) =~ /\$\d+/
+      end
+
       class ConnectionManager
         include Singleton
 
@@ -200,6 +214,10 @@ module NewRelic
         end
 
         def default_sql_obfuscator(sql)
+          if sql[-3,3] == '...'
+            return "Query too large (over 16k characters) to safely obfuscate"
+          end
+
           stmt = sql.kind_of?(Statement) ? sql : Statement.new(sql)
           adapter = stmt.adapter
           obfuscated = remove_escaped_quotes(stmt)

data/lib/new_relic/agent/error_collector.rb

@@ -100,6 +100,11 @@ module NewRelic
           @seen_error_ids << exception.object_id
 
           NewRelic::Agent.get_stats("Errors/all").increment_count
+
+          txn_info = NewRelic::Agent::TransactionInfo.get
+          if (txn_info.transaction_name_set?)
+            NewRelic::Agent.get_stats("Errors/#{txn_info.transaction_name}").increment_count
+          end
         end
 
         # whether we should return early from the notice_error process

data/lib/new_relic/agent/event_listener.rb

@@ -24,6 +24,10 @@ module NewRelic::Agent
       NewRelic::Agent.logger.debug("Run-away event subscription on #{event}? Subscribed #{count}") if count > @runaway_threshold
     end
 
+    def clear
+      @events.clear
+    end
+
     def notify(event, *args)
       return unless @events.has_key?(event)
 

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

@@ -254,7 +254,7 @@ module NewRelic
               return perform_action_without_newrelic_trace(*args)
             end
           end
-          
+
           control = NewRelic::Control.instance
           return perform_action_with_newrelic_profile(args, &block) if control.profiling?
 
@@ -286,7 +286,7 @@ module NewRelic
             # Clear the thread local when finished to ensure it only gets called once.
             frame_data.record_apdex unless ignore_apdex?
             frame_data.pop
-            
+
             NewRelic::Agent::TransactionInfo.get.ignore_end_user = true if ignore_enduser?
           end
         end
@@ -314,14 +314,14 @@ module NewRelic
         def newrelic_request_headers
           self.respond_to?(:request) && self.request.respond_to?(:headers) && self.request.headers
         end
-        
+
         # overrideable method to determine whether to trace an action
         # or not - you may override this in your controller and supply
         # your own logic for ignoring transactions.
         def do_not_trace?
           _is_filtered?('do_not_trace')
         end
-        
+
         # overrideable method to determine whether to trace an action
         # for purposes of apdex measurement - you can use this to
         # ignore things like api calls or other fast non-user-facing
@@ -329,7 +329,7 @@ module NewRelic
         def ignore_apdex?
           _is_filtered?('ignore_apdex')
         end
-        
+
         def ignore_enduser?
           _is_filtered?('ignore_enduser')
         end
@@ -360,6 +360,45 @@ module NewRelic
           frame_data.pop
         end
 
+        def transaction_name(options={})
+          name = "#{category_name(options)}/#{path_name(options)}"
+          NewRelic::Agent.instance.transaction_rules.rename(name)
+        end
+
+        def category_name(options)
+          case options[:category]
+            when :controller, nil then 'Controller'
+            when :task then 'OtherTransaction/Background' # 'Task'
+            when :rack then 'Controller/Rack' #'WebTransaction/Rack'
+            when :uri then 'Controller' #'WebTransaction/Uri'
+            when :sinatra then 'Controller/Sinatra' #'WebTransaction/Uri'
+              # for internal use only
+            else options[:category].to_s
+          end
+        end
+
+        def path_name(options)
+          if options.any?
+            options[:path] || path_class_and_action(options)
+          else
+            newrelic_metric_path
+          end
+        end
+
+        def path_class_and_action(options)
+          metric_class = options[:class_name]
+
+          if !metric_class
+            if (self.is_a?(Class) || self.is_a?(Module))
+              metric_class = self.name
+            else
+              metric_class = self.class.name
+            end
+          end
+
+          [ metric_class, options[:name] ].compact.join('/')
+        end
+
         # Write a metric frame onto a thread local if there isn't already one there.
         # If there is one, just update it.
         def _push_metric_frame(args) # :nodoc:
@@ -367,49 +406,31 @@ module NewRelic
 
           frame_data.apdex_start ||= _detect_upstream_wait(frame_data.start)
           _record_queue_length
+
           # If a block was passed in, then the arguments represent options for the instrumentation,
           # not app method arguments.
+          options = {}
           if args.any?
             if args.last.is_a?(Hash)
-              options = args.last
+              options = args.pop
               frame_data.force_flag = options[:force]
               frame_data.request = options[:request] if options[:request]
             end
-            category, path, available_params = _convert_args_to_path(args)
+            available_params = options[:params] || {}
+            options[:name] ||= args.first
           else
-            category = 'Controller'
-            path = newrelic_metric_path
             available_params = self.respond_to?(:params) ? self.params : {}
           end
           frame_data.request ||= self.request if self.respond_to? :request
-          transaction_name = category + '/' + path
-          frame_data.push(transaction_name)
-          NewRelic::Agent::TransactionInfo.get.transaction_name = transaction_name
+
+          txn_name = transaction_name(options || {})
+
+          frame_data.push(txn_name)
+          NewRelic::Agent::TransactionInfo.get.transaction_name = txn_name
           frame_data.filtered_params = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
           frame_data
         end
 
-        def _convert_args_to_path(args)
-          options =  args.last.is_a?(Hash) ? args.pop : {}
-          params = options[:params] || {}
-          category = case options[:category]
-                     when :controller, nil then 'Controller'
-                     when :task then 'OtherTransaction/Background' # 'Task'
-                     when :rack then 'Controller/Rack' #'WebTransaction/Rack'
-                     when :uri then 'Controller' #'WebTransaction/Uri'
-                     when :sinatra then 'Controller/Sinatra' #'WebTransaction/Uri'
-                       # for internal use only
-                     else options[:category].to_s
-                     end
-          unless path = options[:path]
-            action = options[:name] || args.first
-            metric_class = options[:class_name] || ((self.is_a?(Class)||self.is_a?(Module)) ? self.name : self.class.name)
-            path = metric_class
-            path += ('/' + action) if action
-          end
-          [category, path, params]
-        end
-
         # Filter out a request if it matches one of our parameters for
         # ignoring it - the key is either 'do_not_trace' or 'ignore_apdex'
         def _is_filtered?(key)
@@ -438,23 +459,21 @@ module NewRelic
           end
         end
 
-        include NewRelic::Agent::Instrumentation::QueueTime
-
         # Return a Time instance representing the upstream start time.
         # now is a Time instance to fall back on if no other candidate
         # for the start time is found.
         def _detect_upstream_wait(now)
-          queue_start = nil
           if newrelic_request_headers
-            queue_start = parse_frontend_headers(newrelic_request_headers)
+            queue_start = QueueTime.parse_frontend_timestamp(newrelic_request_headers, now)
+            QueueTime.record_frontend_metrics(queue_start, now) if queue_start
           end
           queue_start || now
         rescue => e
           ::NewRelic::Agent.logger.error("Error detecting upstream wait time:", e)
           now
         end
-        
-        # returns the NewRelic::MethodTraceStats object associated
+
+        # returns the NewRelic::Agent::Stats object associated
         # with the dispatcher time measurement
         def _dispatch_stat
           NewRelic::Agent.agent.stats_engine.get_stats_no_scope 'HttpDispatcher'