newrelic_rpm 3.11.2.286 → 3.12.0.288

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

@@ -29,22 +29,24 @@ module NewRelic
       class ExconHTTPRequest
         def initialize(datum)
           @datum = datum
-        end
 
-        def type
-          "Excon"
-        end
+          @method = @datum[:method].to_s.upcase
+          @scheme = @datum[:scheme]
+          @port   = @datum[:port]
+          @path   = @datum[:path]
 
-        def host
-          if hostname = (self['host'] || self['Host'])
-            hostname.split(':').first
+          headers = @datum[:headers]
+          if hostname = (headers['host'] || headers['Host'])
+            @host = hostname.split(':').first
           else
-            @datum[:host]
+            @host = @datum[:host]
           end
         end
 
-        def method
-          @datum[:method].to_s.upcase
+        attr_reader :host, :method
+
+        def type
+          "Excon"
         end
 
         def [](key)
@@ -57,7 +59,7 @@ module NewRelic
         end
 
         def uri
-          URI.parse("#{@datum[:scheme]}://#{@datum[:host]}:#{@datum[:port]}#{@datum[:path]}")
+          URI.parse("#{@scheme}://#{@host}:#{@port}#{@path}")
         end
       end
     end

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

@@ -36,6 +36,15 @@ module NewRelic
           end
         end
 
+        QUESTION_MARK = "?".freeze
+
+        def self.strip_query_string(fragment)
+          if(fragment.include?(QUESTION_MARK))
+            fragment.split(QUESTION_MARK).first
+          else
+            fragment
+          end
+        end
       end
     end
   end

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

@@ -58,9 +58,7 @@ module NewRelic
         end
 
         def filter(params)
-          munged_params = params.dup
-          munged_params.delete('controller')
-          munged_params.delete('action')
+          munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(params)
           filters = Rails.application.config.filter_parameters
           ActionDispatch::Http::ParameterFilter.new(filters).filter(munged_params)
         end

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

@@ -4,7 +4,7 @@
 require 'new_relic/agent/instrumentation/evented_subscriber'
 
 # Listen for ActiveSupport::Notifications events for ActionView render
-# events.  Write metric data and transaction trace segments for each event.
+# events.  Write metric data and transaction trace nodes for each event.
 module NewRelic
   module Agent
     module Instrumentation

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

@@ -27,7 +27,7 @@ module NewRelic
 
         # @deprecated
         def rollup_metrics_for(*_)
-          NewRelic::Agent::Deprecator.deprecate("#{self.class}.rollup_metrics_for",
+          NewRelic::Agent::Deprecator.deprecate("ActiveRecordHelper.rollup_metrics_for",
                                                 "NewRelic::Agent::Datastores::MetricHelper.metrics_for")
 
           rollup_metric = if NewRelic::Agent::Transaction.recording_web_transaction?

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

@@ -5,7 +5,7 @@ require 'new_relic/agent/instrumentation/active_record_helper'
 require 'new_relic/agent/instrumentation/evented_subscriber'
 
 # Listen for ActiveSupport::Notifications events for ActiveRecord query
-# events.  Write metric data, transaction trace segments and slow sql
+# events.  Write metric data, transaction trace nodes and slow sql
 # nodes for each event.
 module NewRelic
   module Agent
@@ -13,6 +13,13 @@ module NewRelic
       class ActiveRecordSubscriber < EventedSubscriber
         CACHED_QUERY_NAME = 'CACHE'.freeze unless defined? CACHED_QUERY_NAME
 
+        def initialize
+          # We cache this in an instance variable to avoid re-calling method
+          # on each query.
+          @explainer = method(:get_explain_plan)
+          super
+        end
+
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
           return if payload[:name] == CACHED_QUERY_NAME
           return unless NewRelic::Agent.tl_is_execution_traced?
@@ -46,20 +53,20 @@ module NewRelic
         def notice_sql(state, event, config, metric)
           stack  = state.traced_method_stack
 
-          # enter transaction trace segment
+          # enter transaction trace node
           frame = stack.push_frame(state, :active_record, event.time)
 
           NewRelic::Agent.instance.transaction_sampler \
             .notice_sql(event.payload[:sql], config,
                         Helper.milliseconds_to_seconds(event.duration),
-                        state, &method(:get_explain_plan))
+                        state, &@explainer)
 
           NewRelic::Agent.instance.sql_sampler \
             .notice_sql(event.payload[:sql], metric, config,
                         Helper.milliseconds_to_seconds(event.duration),
-                        state, &method(:get_explain_plan))
+                        state, &@explainer)
 
-          # exit transaction trace segment
+          # exit transaction trace node
           stack.pop_frame(state, frame, metric, event.end)
         end
 

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

@@ -11,16 +11,13 @@ module NewRelic
     module Instrumentation
       # == NewRelic instrumentation for controller actions and tasks
       #
-      # This instrumentation is applied to the action controller to collect
-      # metrics for every web request.
-      #
-      # It can also be used to capture performance information for
+      # This module can also be used to capture performance information for
       # background tasks and other non-web transactions, including
       # detailed transaction traces and traced errors.
       #
       # For details on how to instrument background tasks see
-      # ClassMethods#add_transaction_tracer and
-      # #perform_action_with_newrelic_trace
+      # {ClassMethods#add_transaction_tracer} and
+      # {#perform_action_with_newrelic_trace}
       #
       # @api public
       #
@@ -212,6 +209,8 @@ module NewRelic
           end
         end
 
+        # @!parse extend ClassMethods
+
         class TransactionNamer
           def self.name_for(txn, traced_obj, category, options={})
             "#{prefix_for_category(txn, category)}#{path_name(traced_obj, options)}"
@@ -323,7 +322,7 @@ module NewRelic
         #   allows you to set the entire metric after the category part.  Overrides
         #   all the other options.
         # * <tt>:request => Rack::Request#new(env)</tt> is used to pass in a
-        #   request object that may respond to uri and referer.
+        #   request object that may respond to path and referer.
         #
         # @api public
         #

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

@@ -124,13 +124,13 @@ DependencyDetection.defer do
       # tracing if it's enabled.
       def hook_pending_request(request) #THREAD_LOCAL_ACCESS
         wrapped_request, wrapped_response = wrap_request(request)
-        state   = NewRelic::Agent::TransactionState.tl_get
-        t0      = Time.now
-        segment = NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+        state = NewRelic::Agent::TransactionState.tl_get
+        t0    = Time.now
+        node  = NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
 
         unless request._nr_instrumented
           install_header_callback(request, wrapped_response)
-          install_completion_callback(request, t0, segment, wrapped_request, wrapped_response)
+          install_completion_callback(request, t0, node, wrapped_request, wrapped_response)
           request._nr_instrumented = true
         end
       rescue => err
@@ -163,13 +163,13 @@ DependencyDetection.defer do
       end
 
       # Install a callback that will finish the trace.
-      def install_completion_callback(request, t0, segment, wrapped_request, wrapped_response) #THREAD_LOCAL_ACCESS
+      def install_completion_callback(request, t0, node, wrapped_request, wrapped_response) #THREAD_LOCAL_ACCESS
         original_callback = request.on_complete
         request._nr_original_on_complete = original_callback
         request.on_complete do |finished_request|
           begin
             state = NewRelic::Agent::TransactionState.tl_get
-            NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, segment, wrapped_request, wrapped_response)
+            NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, node, wrapped_request, wrapped_response)
           ensure
             # Make sure the existing completion callback is run, and restore the
             # on_complete callback to how it was before.

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

@@ -21,8 +21,8 @@ module ::Excon
             wrapped_request = ::NewRelic::Agent::HTTPClients::ExconHTTPRequest.new(datum)
             state   = ::NewRelic::Agent::TransactionState.tl_get
             t0      = Time.now
-            segment = ::NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
-            datum[:connection].instance_variable_set(TRACE_DATA_IVAR, [t0, segment, wrapped_request])
+            node = ::NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+            datum[:connection].instance_variable_set(TRACE_DATA_IVAR, [t0, node, wrapped_request])
           end
         rescue => e
           NewRelic::Agent.logger.debug(e)
@@ -44,12 +44,12 @@ module ::Excon
         trace_data = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
         if trace_data
           datum[:connection].instance_variable_set(TRACE_DATA_IVAR, nil)
-          t0, segment, wrapped_request = trace_data
+          t0, node, wrapped_request = trace_data
           if datum[:response]
             wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(datum[:response])
           end
           state = ::NewRelic::Agent::TransactionState.tl_get
-          ::NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, segment, wrapped_request, wrapped_response)
+          ::NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, node, wrapped_request, wrapped_response)
         end
       end
     end

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

@@ -19,13 +19,13 @@ module NewRelic
         def handle_transaction(endpoint, class_name)
           return unless endpoint && route = endpoint.route
           name_transaction(route, class_name)
-          capture_params(endpoint) if Agent.config[:capture_params]
+          capture_params(endpoint)
         end
 
         def name_transaction(route, class_name)
           txn_name = name_for_transaction(route, class_name)
-          segment_name = "Middleware/Grape/#{class_name}/call"
-          Transaction.set_default_transaction_name(txn_name, :grape, segment_name)
+          node_name = "Middleware/Grape/#{class_name}/call"
+          Transaction.set_default_transaction_name(txn_name, :grape, node_name)
         end
 
         def name_for_transaction(route, class_name)
@@ -46,6 +46,7 @@ module NewRelic
           params = ParameterFiltering::apply_filters(env, endpoint.params)
           params.delete("route_info")
           txn.filtered_params = params
+          txn.merge_request_parameters(params)
         end
       end
     end

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -96,9 +96,12 @@ DependencyDetection.defer do
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
       def perform_action_with_newrelic_trace_wrapper
-        options = {}
-        options[:params] = (respond_to?(:filter_parameters)) ? filter_parameters(params) : params
-        perform_action_with_newrelic_trace(options) { perform_action_without_newrelic_trace }
+        munged_params = (respond_to?(:filter_parameters)) ? filter_parameters(params) : params
+        munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(munged_params)
+
+        perform_action_with_newrelic_trace(:params => munged_params) do
+          perform_action_without_newrelic_trace
+        end
       end
 
       alias_method :perform_action_without_newrelic_trace, :perform_action

data/lib/new_relic/agent/instrumentation/rails/errors.rb

@@ -24,14 +24,20 @@ DependencyDetection.defer do
       # Make a note of an exception associated with the currently executing
       # controller action.  Note that this used to be available on Object
       # but we replaced that global method with NewRelic::Agent#notice_error.
-      # Use that one outside of controller actions.
+      # Use that one instead.
+      #
+      # @api public
+      # @deprecated
       def newrelic_notice_error(exception, custom_params = {})
-        NewRelic::Agent::Transaction.notice_error exception, :custom_params => custom_params, :request => request
+        NewRelic::Agent::Deprecator.deprecate("ActionController#newrelic_notice_error",
+                                              "NewRelic::Agent#notice_error")
+
+        NewRelic::Agent::Transaction.notice_error exception, :custom_params => custom_params
       end
 
       def rescue_action_with_newrelic_trace(exception)
         rescue_action_without_newrelic_trace exception
-        NewRelic::Agent::Transaction.notice_error exception, :request => request
+        NewRelic::Agent::Transaction.notice_error exception
       end
 
       # Compare with #alias_method_chain, which is not available in

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -19,7 +19,12 @@ module NewRelic
           end
 
           def process_action(*args) #THREAD_LOCAL_ACCESS
-            perform_action_with_newrelic_trace(:category => :controller, :name => self.action_name, :path => newrelic_metric_path, :params => request.filtered_parameters, :class_name => self.class.name)  do
+            munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(request.filtered_parameters)
+            perform_action_with_newrelic_trace(:category => :controller,
+                                               :name => self.action_name,
+                                               :path => newrelic_metric_path,
+                                               :params => munged_params,
+                                               :class_name => self.class.name)  do
               super
             end
           end

data/lib/new_relic/agent/instrumentation/rails3/errors.rb

@@ -7,14 +7,16 @@ module NewRelic
     module Instrumentation
       module Rails3
         module Errors
+
+          # @api public
+          # @deprecated
           def newrelic_notice_error(exception, custom_params = {})
-            filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
-            filtered_params.merge!(custom_params)
-            NewRelic::Agent::Transaction.notice_error( \
-                exception, \
-                :request => request, \
-                :metric => newrelic_metric_path, \
-                :custom_params => filtered_params)
+            NewRelic::Agent::Deprecator.deprecate("ActionController#newrelic_notice_error",
+                                                  "NewRelic::Agent#notice_error")
+
+            NewRelic::Agent::Transaction.notice_error(exception,
+                                                      :metric => newrelic_metric_path,
+                                                      :custom_params => custom_params)
           end
         end
       end

data/lib/new_relic/agent/instrumentation/rails4/errors.rb

@@ -7,13 +7,15 @@ module NewRelic
     module Instrumentation
       module Rails4
         module Errors
+
+          # @api public
+          # @deprecated
           def newrelic_notice_error(exception, custom_params = {})
-            filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
-            filtered_params.merge!(custom_params)
-            NewRelic::Agent::Transaction.notice_error( \
-                exception, \
-                :request => request, \
-                :custom_params => filtered_params)
+            NewRelic::Agent::Deprecator.deprecate("ActionController#newrelic_notice_error",
+                                                  "NewRelic::Agent#notice_error")
+
+            NewRelic::Agent::Transaction.notice_error(exception,
+                                                      :custom_params => custom_params)
           end
         end
       end

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

@@ -27,9 +27,8 @@ DependencyDetection.defer do
                 :class_name => self.name,
                 :category => 'OtherTransaction/ResqueJob') do
 
-                if NewRelic::Agent.config[:'resque.capture_params']
-                  NewRelic::Agent.add_custom_parameters(:job_arguments => args)
-                end
+                NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(args, :'job.resque.args',
+                  NewRelic::Agent::AttributeFilter::DST_NONE)
 
                 yield(*args)
               end

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

@@ -27,9 +27,9 @@ DependencyDetection.defer do
         end
 
         perform_action_with_newrelic_trace(trace_args) do
-          if NewRelic::Agent.config[:'sidekiq.capture_params']
-            NewRelic::Agent.add_custom_parameters(:job_arguments => msg['args'])
-          end
+          NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
+            NewRelic::Agent::AttributeFilter::DST_NONE)
+
           yield
         end
       end

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

@@ -65,10 +65,10 @@ module NewRelic::Agent::Instrumentation::TyphoeusTracing
     if state.is_execution_traced? && !request_is_hydra_enabled?(request)
       wrapped_request = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPRequest.new(request)
       t0 = Time.now
-      segment = ::NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+      node = ::NewRelic::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
       callback = Proc.new do
         wrapped_response = ::NewRelic::Agent::HTTPClients::TyphoeusHTTPResponse.new(request.response)
-        ::NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, segment, wrapped_request, wrapped_response)
+        ::NewRelic::Agent::CrossAppTracing.finish_trace(state, t0, node, wrapped_request, wrapped_response)
       end
       request.on_complete.unshift(callback)
     end

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -127,8 +127,10 @@ module NewRelic
       QUEUE_TIME_KEY       = "queueTime".freeze
       APPLICATION_TIME_KEY = "applicationTime".freeze
       AGENT_KEY            = "agent".freeze
-      USER_ATTRIBUTES_KEY  = "userAttributes".freeze
       SSL_FOR_HTTP_KEY     = "sslForHttp".freeze
+      ATTS_KEY             = "atts".freeze
+      ATTS_USER_SUBKEY     = "u".freeze
+      ATTS_AGENT_SUBKEY    = "a".freeze
 
       # NOTE: Internal prototyping may override this, so leave name stable!
       def data_for_js_agent(state)
@@ -146,7 +148,7 @@ module NewRelic
         }
 
         add_ssl_for_http(data)
-        add_user_attributes(data, state.current_transaction)
+        add_attributes(data, state.current_transaction)
 
         data
       end
@@ -158,25 +160,31 @@ module NewRelic
         end
       end
 
-      def add_user_attributes(data, txn)
-        return unless include_custom_parameters?(txn)
+      def add_attributes(data, txn)
+        return unless txn
 
-        params = event_params(txn.custom_parameters)
-        json = NewRelic::JSONWrapper.dump(params)
-        data[USER_ATTRIBUTES_KEY] = obfuscator.obfuscate(json)
+        atts = {}
+        append_custom_attributes!(txn, atts)
+        append_agent_attributes!(txn, atts)
+
+        unless atts.empty?
+          json = NewRelic::JSONWrapper.dump(atts)
+          data[ATTS_KEY] = obfuscator.obfuscate(json)
+        end
       end
 
-      # Still support deprecated capture_attributes.page_view_events for
-      # clients that use it. Could potentially be removed if we don't have
-      # anymore users with it set according to zeitgeist.
-      def include_custom_parameters?(txn)
-        has_custom_parameters?(txn) &&
-          (NewRelic::Agent.config[:'browser_monitoring.capture_attributes'] ||
-           NewRelic::Agent.config[:'capture_attributes.page_view_events'])
+      def append_custom_attributes!(txn, atts)
+        custom_attributes = txn.attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_BROWSER_MONITORING)
+        unless custom_attributes.empty?
+          atts[ATTS_USER_SUBKEY] = custom_attributes
+        end
       end
 
-      def has_custom_parameters?(txn)
-        txn && txn.custom_parameters && !txn.custom_parameters.empty?
+      def append_agent_attributes!(txn, atts)
+        agent_attributes = txn.attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_BROWSER_MONITORING)
+        unless agent_attributes.empty?
+          atts[ATTS_AGENT_SUBKEY] = agent_attributes
+        end
       end
 
       def html_safe_if_needed(string)