newrelic_rpm 3.11.2.286 → 3.12.0.288

data/lib/new_relic/agent/parameter_filtering.rb

@@ -32,6 +32,13 @@ module NewRelic
           memo
         end
       end
+
+      def filter_rails_request_parameters(params)
+        result = params.dup
+        result.delete("controller")
+        result.delete("action")
+        result
+      end
     end
   end
-end
+end

data/lib/new_relic/agent/samplers/delayed_job_sampler.rb

@@ -80,12 +80,12 @@ module NewRelic
 
         QUEUE_QUERY_CONDITION = 'run_at <= ? and failed_at is NULL'.freeze
 
-        def record_counts_by(column_name, metric_segment = column_name)
+        def record_counts_by(column_name, metric_node = column_name)
           all_count = 0
           queue_counts(column_name).each do |column_val, count|
             all_count += count
             column_val = "default" if column_val.nil? || column_val == ""
-            metric = "Workers/DelayedJob/queue_length/#{metric_segment}/#{column_val}"
+            metric = "Workers/DelayedJob/queue_length/#{metric_node}/#{column_val}"
             NewRelic::Agent.record_metric(metric, count)
           end
           all_count

data/lib/new_relic/agent/sql_sampler.rb

@@ -148,6 +148,7 @@ module NewRelic
       #                         not pass this parameter.
       #
       # @api public
+      # @deprecated Use {Datastores.notice_sql} instead.
       #
       def notice_sql(sql, metric_name, config, duration, state=nil, &explainer) #THREAD_LOCAL_ACCESS sometimes
         state ||= TransactionState.tl_get

data/lib/new_relic/agent/stats.rb

@@ -95,10 +95,6 @@ module NewRelic
         @call_count += value
       end
 
-      def inspect
-        "#<NewRelic::Agent::Stats #{to_s} >"
-      end
-
       # Concerned about implicit usage of inspect relying on stats format, so
       # putting back a version to get full inspection as separate method
       def inspect_full

data/lib/new_relic/agent/stats_engine/metric_stats.rb

@@ -6,8 +6,10 @@ require 'new_relic/language_support'
 
 module NewRelic
   module Agent
+    # @api public
     class StatsEngine
       # Handles methods related to actual Metric collection
+      # @api public
       module MetricStats
         SCOPE_PLACEHOLDER = '__SCOPE__'.freeze
 
@@ -108,13 +110,13 @@ module NewRelic
         end
 
         # This method is deprecated and not thread safe, and should not be used
-        # by any new client code. Use NewRelic::Agent.record_metric instead.
+        # by any new client code.
         #
         # Lookup the Stats object for a given unscoped metric, returning a new
         # Stats object if one did not exist previously.
         #
         # @api public
-        # @deprecated
+        # @deprecated Use {::NewRelic::Agent.record_metric} instead.
         #
         def get_stats_no_scope(metric_name)
           get_stats(metric_name, false)
@@ -128,7 +130,7 @@ module NewRelic
         # Leaving second, unused parameter for compatibility
         #
         # @api public
-        # @deprecated
+        # @deprecated Use {::NewRelic::Agent.record_metric} instead.
         #
         def get_stats(metric_name, _ = true, scoped_metric_only = false, scope = nil)
           stats = nil

data/lib/new_relic/agent/stats_engine/stats_hash.rb

@@ -44,6 +44,10 @@ module NewRelic
         Hash[self] == Hash[other]
       end
 
+      def to_h
+        Hash[self]
+      end
+
       class StatsHashLookupError < NewRelic::Agent::InternalAgentError
         def initialize(original_error, hash, metric_spec)
           super("Lookup error in StatsHash: #{original_error.class}: #{original_error.message}. Falling back adding #{metric_spec.inspect}")

data/lib/new_relic/agent/supported_versions.rb

@@ -125,7 +125,7 @@ module NewRelic
       :activerecord =>
       {
         :type        => :database,
-        :supported   => ["~>2.1.0", "~>2.2.0", "~>2.3.0", "~3.0.0", "~>3.1.0", "~>3.2.0", "~>4.0.0"],
+        :supported   => ["~>2.1.0", "~>2.2.0", "~>2.3.0", "~>3.0.0", "~>3.1.0", "~>3.2.0", "~>4.0.0", "~>4.1.0", "~>4.2.0"],
         :deprecated  => ["~>2.0.0"],
         :url         => "https://rubygems.org/gems/activerecord",
         :feed        => "https://rubygems.org/gems/activerecord/versions.atom",
@@ -148,7 +148,7 @@ module NewRelic
       :mongo =>
       {
         :type        => :database,
-        :supported   => ["~>1.8.0", "~>1.9.0", "~>1.10.0"],
+        :supported   => [">= 1.8.0", "< 2.0.0"],
         :url         => "https://rubygems.org/gems/mongo",
         :feed        => "https://rubygems.org/gems/mongo/versions.atom"
       },

data/lib/new_relic/agent/traced_method_stack.rb

@@ -24,9 +24,9 @@ module NewRelic
       end
 
       # Pushes a frame onto the transaction stack - this generates a
-      # TransactionSample::Segment at the end of transaction execution.
+      # Agent::Transaction::TraceNode at the end of transaction execution.
       #
-      # The generated segment won't be named until pop_frame is called.
+      # The generated node won't be named until pop_frame is called.
       #
       # +tag+ should be a Symbol, and is only for debugging purposes to
       # identify this frame if the stack gets corrupted.
@@ -43,7 +43,7 @@ module NewRelic
       # +expected_frame+ should be TracedMethodFrame from the corresponding
       # push_frame call.
       #
-      # +name+ will be applied to the generated transaction trace segment.
+      # +name+ will be applied to the generated transaction trace node.
       def pop_frame(state, expected_frame, name, time, deduct_call_time_from_parent=true)
         frame = fetch_matching_frame(expected_frame)
 

data/lib/new_relic/agent/transaction.rb

@@ -6,6 +6,7 @@ require 'new_relic/agent/transaction_timings'
 require 'new_relic/agent/instrumentation/queue_time'
 require 'new_relic/agent/transaction_metrics'
 require 'new_relic/agent/method_tracer_helpers'
+require 'new_relic/agent/transaction/attributes'
 
 module NewRelic
   module Agent
@@ -51,17 +52,15 @@ module NewRelic
                     :process_cpu_start,
                     :http_response_code
 
-      # Give the current transaction a request context.  Use this to
-      # get the URI and referer.  The request is interpreted loosely
-      # as a Rack::Request or an ActionController::AbstractRequest.
-      attr_accessor :request
-
       attr_reader :guid,
                   :metrics,
                   :gc_start_snapshot,
                   :category,
                   :frame_stack,
-                  :cat_path_hashes
+                  :cat_path_hashes,
+                  :attributes,
+                  :request_path,
+                  :referer
 
       # Populated with the trace sample once this transaction is completed.
       attr_reader :transaction_trace
@@ -74,10 +73,10 @@ module NewRelic
         TransactionState.tl_get.current_transaction
       end
 
-      def self.set_default_transaction_name(name, category = nil, segment_name = nil) #THREAD_LOCAL_ACCESS
+      def self.set_default_transaction_name(name, category = nil, node_name = nil) #THREAD_LOCAL_ACCESS
         txn  = tl_current
         name = txn.make_transaction_name(name, category)
-        txn.name_last_frame(segment_name || name)
+        txn.name_last_frame(node_name || name)
         txn.set_default_transaction_name(name, category)
       end
 
@@ -186,18 +185,8 @@ module NewRelic
         txn.abort_transaction!(state) if txn
       end
 
-      # If we have an active transaction, notice the error and increment the error metric.
-      # Options:
-      # * <tt>:request</tt> => Request object to get the uri and referer
-      # * <tt>:uri</tt> => The request path, minus any request params or query string.
-      # * <tt>:referer</tt> => The URI of the referer
-      # * <tt>:metric</tt> => The metric name associated with the transaction
-      # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
-      # * <tt>:custom_params</tt> => Custom parameters
-      # Anything left over is treated as custom params
-
+      # See NewRelic::Agent.notice_error for options and commentary
       def self.notice_error(e, options={}) #THREAD_LOCAL_ACCESS
-        options = extract_request_options(options)
         state = NewRelic::Agent::TransactionState.tl_get
         txn = state.current_transaction
         if txn
@@ -207,15 +196,6 @@ module NewRelic
         end
       end
 
-      def self.extract_request_options(options)
-        req = options.delete(:request)
-        if req
-          options[:uri]     = uri_from_request(req)
-          options[:referer] = referer_from_request(req)
-        end
-        options
-      end
-
       # Returns truthy if the current in-progress transaction is considered a
       # a web transaction (as opposed to, e.g., a background transaction).
       #
@@ -226,27 +206,6 @@ module NewRelic
         txn && txn.recording_web_transaction?
       end
 
-      # Make a safe attempt to get the referer from a request object, generally successful when
-      # it's a Rack request.
-      def self.referer_from_request(req)
-        if req && req.respond_to?(:referer)
-          req.referer.to_s.split('?').first
-        end
-      end
-
-      # Make a safe attempt to get the URI, without the host and query string.
-      def self.uri_from_request(req)
-        approximate_uri = case
-                          when req.respond_to?(:fullpath   ) then req.fullpath
-                          when req.respond_to?(:path       ) then req.path
-                          when req.respond_to?(:request_uri) then req.request_uri
-                          when req.respond_to?(:uri        ) then req.uri
-                          when req.respond_to?(:url        ) then req.url
-                          end
-        return approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri
-      end
-
-
       def self.apdex_bucket(duration, failed, apdex_t)
         case
         when failed
@@ -260,6 +219,30 @@ module NewRelic
         end
       end
 
+      def self.add_agent_attribute(key, value, default_destinations)
+        if txn = tl_current
+          txn.add_agent_attribute(key, value, default_destinations)
+        else
+          NewRelic::Agent.logger.debug "Attempted to add agent attribute: #{key} without transaction"
+        end
+      end
+
+      def add_agent_attribute(key, value, default_destinations)
+        @attributes.add_agent_attribute(key, value, default_destinations)
+      end
+
+      def self.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
+        if txn = tl_current
+          txn.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
+        else
+          NewRelic::Agent.logger.debug "Attempted to merge untrusted attributes without transaction"
+        end
+      end
+
+      def merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
+        @attributes.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
+      end
+
       @@java_classes_loaded = false
 
       if defined? JRuby
@@ -287,7 +270,7 @@ module NewRelic
         @process_cpu_start = process_cpu
         @gc_start_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
         @filtered_params = options[:filtered_params] || {}
-        @request = options[:request]
+
         @exceptions = {}
         @metrics = TransactionMetrics.new
         @guid = generate_guid
@@ -296,6 +279,15 @@ module NewRelic
         @ignore_this_transaction = false
         @ignore_apdex = false
         @ignore_enduser = false
+
+        @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
+
+        merge_request_parameters(@filtered_params)
+
+        if request = options[:request]
+          @request_path = path_from_request(request)
+          @referer = referer_from_request(request)
+        end
       end
 
       # This transaction-local hash may be used as temprory storage by
@@ -332,6 +324,7 @@ module NewRelic
         @has_children = true
         if options[:filtered_params] && !options[:filtered_params].empty?
           @filtered_params = options[:filtered_params]
+          merge_request_parameters(options[:filtered_params])
         end
 
         frame_stack.push NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, Time.now.to_f)
@@ -340,6 +333,10 @@ module NewRelic
         set_default_transaction_name(options[:transaction_name], category)
       end
 
+      def merge_request_parameters(params)
+        merge_untrusted_agent_attributes(params, :'request.parameters', AttributeFilter::DST_NONE)
+      end
+
       def make_transaction_name(name, category=nil)
         namer = Instrumentation::ControllerInstrumentation::TransactionNamer
         "#{namer.prefix_for_category(self, category)}#{name}"
@@ -417,8 +414,8 @@ module NewRelic
       def start(state)
         return if !state.is_execution_traced?
 
-        transaction_sampler.on_start_transaction(state, start_time, uri)
-        sql_sampler.on_start_transaction(state, start_time, uri)
+        transaction_sampler.on_start_transaction(state, start_time)
+        sql_sampler.on_start_transaction(state, start_time, request_path)
         NewRelic::Agent.instance.events.notify(:start_transaction)
         NewRelic::Agent::BusyCalculator.dispatcher_start(start_time)
 
@@ -426,19 +423,10 @@ module NewRelic
         name_last_frame @default_name
       end
 
-      # For the current web transaction, return the path of the URI minus the host part and query string, or nil.
-      def uri
-        @uri ||= self.class.uri_from_request(@request) unless @request.nil?
-      end
-
-      # For the current web transaction, return the full referer, minus the host string, or nil.
-      def referer
-        @referer ||= self.class.referer_from_request(@request)
-      end
-
-      # Call this to ensure that the current transaction is not saved
+      # Call this to ensure that the current transaction trace is not saved
+      # To fully ignore all metrics and errors, use ignore! instead.
       def abort_transaction!(state)
-        transaction_sampler.ignore_transaction(state)
+        @ignore_trace = true
       end
 
       WEB_SUMMARY_METRIC   = 'HttpDispatcher'.freeze
@@ -502,29 +490,22 @@ module NewRelic
       end
 
       def user_defined_rules_ignore?
-        return unless uri
+        return unless request_path
         return if (rules = NewRelic::Agent.config[:"rules.ignore_url_regexes"]).empty?
 
-        parsed = NewRelic::Agent::HTTPClients::URIUtil.parse_url(uri)
-        filtered_uri = NewRelic::Agent::HTTPClients::URIUtil.filter_uri(parsed)
-
         rules.any? do |rule|
-          filtered_uri.match(rule)
+          request_path.match(rule)
         end
-      rescue URI::InvalidURIError => e
-        NewRelic::Agent.logger.debug("Error parsing URI: #{uri}", e)
-        false
       end
 
-      def commit!(state, end_time, outermost_segment_name)
-        record_transaction_cpu(state)
-        gc_stop_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
-        gc_delta = NewRelic::Agent::StatsEngine::GCProfiler.record_delta(
-            gc_start_snapshot, gc_stop_snapshot)
-        @transaction_trace = transaction_sampler.on_finishing_transaction(state, self, end_time, gc_delta)
+      def commit!(state, end_time, outermost_node_name)
+        assign_agent_attributes
+        assign_intrinsics(state)
+
+        @transaction_trace = transaction_sampler.on_finishing_transaction(state, self, end_time)
         sql_sampler.on_finishing_transaction(state, @frozen_name)
 
-        record_summary_metrics(outermost_segment_name, end_time)
+        record_summary_metrics(outermost_node_name, end_time)
         record_apdex(state, end_time) unless ignore_apdex?
         record_queue_time
 
@@ -534,11 +515,51 @@ module NewRelic
         send_transaction_finished_event(state, start_time, end_time)
       end
 
+      def assign_agent_attributes
+        if referer
+          add_agent_attribute(:'request.headers.referer', referer,
+                              NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR)
+        end
+
+        if http_response_code
+          add_agent_attribute(:httpResponseCode, http_response_code,
+                              NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER|
+                              NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS|
+                              NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR)
+        end
+      end
+
+      def assign_intrinsics(state)
+        if gc_time = calculate_gc_time
+          attributes.add_intrinsic_attribute(:gc_time, gc_time)
+        end
+
+        if burn = cpu_burn
+          attributes.add_intrinsic_attribute(:cpu_time, burn)
+        end
+
+        if is_synthetics_request?
+          attributes.add_intrinsic_attribute(:synthetics_resource_id, synthetics_resource_id)
+          attributes.add_intrinsic_attribute(:synthetics_job_id, synthetics_job_id)
+          attributes.add_intrinsic_attribute(:synthetics_monitor_id, synthetics_monitor_id)
+        end
+
+        if state.is_cross_app?
+          attributes.add_intrinsic_attribute(:trip_id, cat_trip_id(state))
+          attributes.add_intrinsic_attribute(:path_hash, cat_path_hash(state))
+        end
+      end
+
+      def calculate_gc_time
+        gc_stop_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
+        NewRelic::Agent::StatsEngine::GCProfiler.record_delta(gc_start_snapshot, gc_stop_snapshot)
+      end
+
       # The summary metrics recorded by this method all end up with a duration
       # equal to the transaction itself, and an exclusive time of zero.
-      def record_summary_metrics(outermost_segment_name, end_time)
+      def record_summary_metrics(outermost_node_name, end_time)
         metrics = summary_metrics
-        metrics << @frozen_name unless @frozen_name == outermost_segment_name
+        metrics << @frozen_name unless @frozen_name == outermost_node_name
         @metrics.record_unscoped(metrics, end_time.to_f - start_time.to_f, 0)
       end
 
@@ -547,12 +568,12 @@ module NewRelic
       def send_transaction_finished_event(state, start_time, end_time)
         duration = end_time.to_f - start_time.to_f
         payload = {
-          :name             => @frozen_name,
-          :bucket           => recording_web_transaction? ? :request : :background,
-          :start_timestamp  => start_time.to_f,
-          :duration         => duration,
-          :metrics          => @metrics,
-          :custom_params    => custom_parameters
+          :name                 => @frozen_name,
+          :bucket               => recording_web_transaction? ? :request : :background,
+          :start_timestamp      => start_time.to_f,
+          :duration             => duration,
+          :metrics              => @metrics,
+          :attributes           => @attributes,
         }
         append_cat_info(state, duration, payload)
         append_apdex_perf_zone(duration, payload)
@@ -688,22 +709,16 @@ module NewRelic
 
       def record_exceptions
         @exceptions.each do |exception, options|
-          options[:metric] = best_name
+          options[:uri]      ||= request_path if request_path
+          options[:metric]     = best_name
+          options[:attributes] = @attributes
+
           agent.error_collector.notice_error(exception, options)
         end
       end
 
       # Do not call this.  Invoke the class method instead.
       def notice_error(error, options={}) # :nodoc:
-        options[:uri]     ||= uri     if uri
-        options[:referer] ||= referer if referer
-
-        if filtered_params && !filtered_params.empty?
-          options[:request_params] = filtered_params
-        end
-
-        options.merge!(custom_parameters)
-
         if @exceptions[error]
           @exceptions[error].merge! options
         else
@@ -772,7 +787,7 @@ module NewRelic
 
         @metrics.record_unscoped(rollup_metric, apdex_bucket_global, current_apdex_t)
         @metrics.record_unscoped(APDEX_ALL_METRIC, apdex_bucket_global, current_apdex_t)
-        txn_apdex_metric = @frozen_name.gsub(/^[^\/]+\//, transaction_prefix)
+        txn_apdex_metric = @frozen_name.sub(/^[^\/]+\//, transaction_prefix)
         @metrics.record_unscoped(txn_apdex_metric, apdex_bucket_txn, current_apdex_t)
       end
 
@@ -801,21 +816,12 @@ module NewRelic
         self.instrumentation_state[:datastore_override] = previous
       end
 
-      def custom_parameters
-        @custom_parameters ||= {}
-      end
-
-      def add_custom_parameters(p)
-        if NewRelic::Agent.config[:high_security]
-          NewRelic::Agent.logger.debug("Unable to add custom attributes #{p.keys.inspect} while in high security mode.")
-          return
-        end
-
-        custom_parameters.merge!(p)
+      def add_custom_attributes(p)
+        attributes.merge_custom_attributes(p)
       end
 
-      alias_method :user_attributes, :custom_parameters
-      alias_method :set_user_attributes, :add_custom_parameters
+      alias_method :set_user_attributes, :add_custom_attributes
+      alias_method :add_custom_parameters, :add_custom_attributes
 
       def recording_web_transaction?
         web_category?(@category)
@@ -843,13 +849,6 @@ module NewRelic
         jruby_cpu_time - @jruby_cpu_start
       end
 
-      def record_transaction_cpu(state)
-        burn = cpu_burn
-        if burn
-          transaction_sampler.notice_transaction_cpu_time(state, burn)
-        end
-      end
-
       def ignore!
         @ignore_this_transaction = true
       end
@@ -874,6 +873,10 @@ module NewRelic
         @ignore_enduser
       end
 
+      def ignore_trace?
+        @ignore_trace
+      end
+
       private
 
       def process_cpu
@@ -921,6 +924,26 @@ module NewRelic
         guid
       end
 
+      # Make a safe attempt to get the referer from a request object, generally successful when
+      # it's a Rack request.
+      def referer_from_request(req)
+        if req && req.respond_to?(:referer) && req.referer
+          HTTPClients::URIUtil.strip_query_string(req.referer.to_s)
+        end
+      end
+
+      # In practice we expect req to be a Rack::Request or ActionController::AbstractRequest
+      # (for older Rails versions).  But anything that responds to path can be passed to
+      # perform_action_with_newrelic_trace.
+      #
+      # We don't expect the path to include a query string, however older test helpers for
+      # rails construct the PATH_INFO enviroment variable improperly and we're generally
+      # being defensive.
+      def path_from_request(req)
+        path = req.path
+        path = HTTPClients::URIUtil.strip_query_string(path)
+        path.empty? ? "/" : path
+      end
     end
   end
 end