newrelic_rpm 4.1.0.333 → 4.2.0.334

data/lib/new_relic/agent/supported_versions.rb

@@ -78,7 +78,7 @@ module NewRelic
       :rails =>
       {
         :type        => :web,
-        :supported   => ["~3.0.0", "~>3.1.0", "~>3.2.0", "~>4.0.0", "~>4.1.0", "~>4.2.0", "~>5.0.0"],
+        :supported   => ["~3.0.0", "~>3.1.0", "~>3.2.0", "~>4.0.0", "~>4.1.0", "~>4.2.0", "~>5.0.0", "~>5.1.0"],
         :deprecated  => ["~>2.0.0", "~>2.1.0", "~>2.2.0", "~>2.3.0"],
         :url         => "https://rubygems.org/gems/rails",
         :feed        => "https://rubygems.org/gems/rails/versions.atom",
@@ -88,7 +88,7 @@ module NewRelic
       :sinatra =>
       {
         :type        => :web,
-        :supported   => ["~>1.2.0", "~>1.3.0", "~>1.4.0"],
+        :supported   => ["~>1.2.0", "~>1.3.0", "~>1.4.0", "~>2.0.0"],
         :url         => "https://rubygems.org/gems/sinatra",
         :feed        => "https://rubygems.org/gems/sinatra/versions.atom"
       },
@@ -119,11 +119,12 @@ 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", "~>4.1.0", "~>4.2.0"],
-        :deprecated  => ["~>2.0.0"],
+        :supported   => ["~>3.0.0", "~>3.1.0", "~>3.2.0", "~>4.0.0", "~>4.1.0", "~>4.2.0", "~>5.0.0", "~>5.1.0"],
+        :deprecated  => ["~>2.0.0", "~>2.1.0", "~>2.2.0", "~>2.3.0",],
         :url         => "https://rubygems.org/gems/activerecord",
         :feed        => "https://rubygems.org/gems/activerecord/versions.atom",
-        :notes       => ["Last supported agent for 2.0.x was 3.6.8.168"]
+        :notes       => ["Last supported agent for ~>2.1.0, ~>2.2.0, and ~>2.3.0 was 3.18.1.330.",
+                         "Last supported agent for 2.0.x was 3.6.8.168."]
       },
       :datamapper =>
       {

data/lib/new_relic/agent/transaction.rb

@@ -31,17 +31,10 @@ module NewRelic
       ACTION_CABLE_PREFIX          = 'Controller/ActionCable/'.freeze
       OTHER_TRANSACTION_PREFIX     = 'OtherTransaction/'.freeze
 
-      CONTROLLER_MIDDLEWARE_PREFIX = 'Controller/Middleware/Rack'.freeze
-
-      NESTED_TRACE_STOP_OPTIONS    = { :metric => true }.freeze
       WEB_TRANSACTION_CATEGORIES   = [:controller, :uri, :rack, :sinatra, :grape, :middleware, :action_cable].freeze
       TRANSACTION_NAMING_SOURCES   = [:child, :api].freeze
 
       MIDDLEWARE_SUMMARY_METRICS   = ['Middleware/all'.freeze].freeze
-      EMPTY_SUMMARY_METRICS        = [].freeze
-
-      TRACE_OPTIONS_SCOPED         = { :metric => true, :scoped_metric => true }.freeze
-      TRACE_OPTIONS_UNSCOPED       = { :metric => true, :scoped_metric => false }.freeze
 
       # reference to the transaction state managing this transaction
       attr_accessor :state
@@ -69,7 +62,9 @@ module NewRelic
                   :frame_stack,
                   :cat_path_hashes,
                   :attributes,
-                  :payload
+                  :payload,
+                  :nesting_max_depth,
+                  :segments
 
       # Populated with the trace sample once this transaction is completed.
       attr_reader :transaction_trace
@@ -154,22 +149,7 @@ module NewRelic
           txn.stop(state, end_time, nested_frame)
           state.reset
         else
-          nested_name = nested_transaction_name(nested_frame.name)
-
-          if nested_name.start_with?(MIDDLEWARE_PREFIX)
-            summary_metrics = MIDDLEWARE_SUMMARY_METRICS
-          else
-            summary_metrics = EMPTY_SUMMARY_METRICS
-          end
-
-          NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_footer(
-            state,
-            nested_frame.start_time.to_f,
-            nested_name,
-            summary_metrics,
-            nested_frame,
-            NESTED_TRACE_STOP_OPTIONS,
-            end_time.to_f)
+          nested_frame.finish
         end
 
         :transaction_stopped
@@ -266,8 +246,10 @@ module NewRelic
       end
 
       def initialize(category, options)
+        @nesting_max_depth = 0
+        @current_segment = nil
+        @segments = []
         @frame_stack = []
-        @has_children = false
 
         self.default_name = options[:transaction_name]
         @overridden_name    = nil
@@ -287,8 +269,8 @@ module NewRelic
         @cat_path_hashes = nil
 
         @ignore_this_transaction = false
-        @ignore_apdex = false
-        @ignore_enduser = false
+        @ignore_apdex = options.fetch(:ignore_apdex, false)
+        @ignore_enduser = options.fetch(:ignore_enduser, false)
         @ignore_trace = false
 
         @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
@@ -340,19 +322,6 @@ module NewRelic
         @default_name = Helper.correctly_encoded(name)
       end
 
-      def create_nested_frame(state, category, options)
-        @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)
-        name_last_frame(options[:transaction_name])
-
-        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
@@ -379,6 +348,7 @@ module NewRelic
       end
 
       def name_last_frame(name)
+        name = self.class.nested_transaction_name(name) if nesting_max_depth > 1
         frame_stack.last.name = name
       end
 
@@ -439,8 +409,49 @@ module NewRelic
         NewRelic::Agent.instance.events.notify(:start_transaction)
         NewRelic::Agent::BusyCalculator.dispatcher_start(start_time)
 
-        frame_stack.push NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, start_time.to_f)
-        name_last_frame @default_name
+        create_initial_segment @default_name
+      end
+
+      def initial_segment
+        segments.first
+      end
+
+      def create_initial_segment name
+        segment = create_segment @default_name
+        segment.record_scoped_metric = false
+      end
+
+      def create_segment(name)
+        summary_metrics = nil
+
+        if name.start_with?(MIDDLEWARE_PREFIX)
+          summary_metrics = MIDDLEWARE_SUMMARY_METRICS
+        end
+
+        @nesting_max_depth += 1
+        segment = self.class.start_segment name, summary_metrics
+        frame_stack.push segment
+        segment
+      end
+
+      def create_nested_frame(state, category, options)
+        if options[:filtered_params] && !options[:filtered_params].empty?
+          @filtered_params = options[:filtered_params]
+          merge_request_parameters(options[:filtered_params])
+        end
+
+        @ignore_apdex = options[:ignore_apdex] if options.key? :ignore_apdex
+        @ignore_enduser = options[:ignore_enduser] if options.key? :ignore_enduser
+
+        nest_initial_segment if nesting_max_depth == 1
+        nested_name = self.class.nested_transaction_name options[:transaction_name]
+        create_segment nested_name
+        set_default_transaction_name(options[:transaction_name], category)
+      end
+
+      def nest_initial_segment
+        self.initial_segment.name = self.class.nested_transaction_name initial_segment.name
+        initial_segment.record_scoped_metric = true
       end
 
       # Call this to ensure that the current transaction trace is not saved
@@ -478,35 +489,15 @@ module NewRelic
         freeze_name_and_execute_if_not_ignored
         ignore! if user_defined_rules_ignore?
 
-        if @has_children
-          name = Transaction.nested_transaction_name(outermost_frame.name)
-          trace_options = TRACE_OPTIONS_SCOPED
-        else
-          name = @frozen_name
-          trace_options = TRACE_OPTIONS_UNSCOPED
+        if nesting_max_depth == 1
+          outermost_frame.name = @frozen_name
         end
 
-        # These metrics are recorded here instead of in record_summary_metrics
-        # in order to capture the exclusive time associated with the outer-most
-        # TT node.
-        if needs_middleware_summary_metrics?(name)
-          summary_metrics_with_exclusive_time = MIDDLEWARE_SUMMARY_METRICS
-        else
-          summary_metrics_with_exclusive_time = EMPTY_SUMMARY_METRICS
-        end
-
-        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_footer(
-          state,
-          start_time.to_f,
-          name,
-          summary_metrics_with_exclusive_time,
-          outermost_frame,
-          trace_options,
-          end_time.to_f)
+        outermost_frame.finish
 
         NewRelic::Agent::BusyCalculator.dispatcher_finish(end_time)
 
-        commit!(state, end_time, name) unless @ignore_this_transaction
+        commit!(state, end_time, outermost_frame.name) unless @ignore_this_transaction
       end
 
       def user_defined_rules_ignore?
@@ -525,6 +516,7 @@ module NewRelic
         @transaction_trace = transaction_sampler.on_finishing_transaction(state, self, end_time)
         sql_sampler.on_finishing_transaction(state, @frozen_name)
 
+        segments.each { |s| s.record_metrics if s.record_metrics? }
         record_summary_metrics(outermost_node_name, end_time)
         record_apdex(state, end_time) unless ignore_apdex?
         record_queue_time
@@ -533,7 +525,6 @@ module NewRelic
 
         record_exceptions
         record_transaction_event
-
         merge_metrics
         send_transaction_finished_event
       end

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -7,13 +7,18 @@ module NewRelic
     class Transaction
       class AbstractSegment
         attr_reader :start_time, :end_time, :duration, :exclusive_duration
-        attr_accessor :name, :children_time, :transaction
+        attr_accessor :name, :parent, :children_time, :transaction
+        attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
 
         def initialize name=nil
           @name = name
           @children_time = 0.0
           @record_metrics = true
+          @record_scoped_metric = true
           @transaction = nil
+          @parent = nil
+          @record_on_finish = false
+          @params = nil
         end
 
         def start
@@ -25,8 +30,9 @@ module NewRelic
           @duration = end_time.to_f - start_time.to_f
           @exclusive_duration = duration - children_time
           if transaction
-            record_metrics if record_metrics?
+            record_metrics if record_metrics? && record_on_finish?
             segment_complete
+            parent.child_complete self if parent
             transaction.segment_complete self
           end
         rescue => e
@@ -40,14 +46,26 @@ module NewRelic
           @record_metrics
         end
 
-        def record_metrics= value
-          @record_metrics = value
+        def record_scoped_metric?
+          @record_scoped_metric
+        end
+
+        def record_on_finish?
+          @record_on_finish
         end
 
         def record_metrics
           raise NotImplementedError, "Subclasses must implement record_metrics"
         end
 
+        def params
+          @params ||= {}
+        end
+
+        def params?
+          !!@params
+        end
+
         INSPECT_IGNORE = [:@transaction, :@transaction_state].freeze
 
         def inspect
@@ -57,10 +75,21 @@ module NewRelic
           sprintf('#<%s:0x%x %s>', self.class.name, object_id, ivars.join(', '))
         end
 
+        protected
+
+        def child_complete segment
+          if segment.record_metrics?
+            self.children_time += segment.duration
+          else
+            self.children_time += segment.children_time
+          end
+        end
+
         private
 
         # callback for subclasses to override
         def segment_complete
+          raise NotImplementedError
         end
 
         def metric_cache

data/lib/new_relic/agent/transaction/datastore_segment.rb

@@ -55,6 +55,7 @@ module NewRelic
 
         def notice_sql sql
           _notice_sql sql
+          nil
         end
 
         # @api private
@@ -65,52 +66,52 @@ module NewRelic
 
         def notice_nosql_statement nosql_statement
           return unless record_sql?
-          @nosql_statement = nosql_statement
+          @nosql_statement = Database.truncate_query(nosql_statement)
+          nil
         end
 
-        private
-
         def record_metrics
           @unscoped_metrics = Datastores::MetricHelper.unscoped_metrics_for(product, operation, collection, host, port_path_or_id)
           super
         end
 
+        private
+
         def segment_complete
-          add_segment_parameters
           notice_sql_statement if sql_statement
           notice_statement if nosql_statement
-        end
-
-        def add_segment_parameters
-          instance_reporting_enabled = NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
-          db_name_reporting_enabled = NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
-          return unless instance_reporting_enabled || db_name_reporting_enabled
+          add_instance_parameters
+          add_database_name_parameter
+          add_backtrace_parameter
 
-          params = {}
-          add_instance_parameters params if instance_reporting_enabled
-          add_database_name_parameter params if db_name_reporting_enabled
-
-          NewRelic::Agent.instance.transaction_sampler.add_node_parameters params
+          super
         end
 
-        def add_instance_parameters params
+        def add_instance_parameters
+          return unless NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
           params[:host] = host if host
           params[:port_path_or_id] = port_path_or_id if port_path_or_id
         end
 
-        def add_database_name_parameter(params)
+        def add_database_name_parameter
+          return unless NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
           params[:database_name] = database_name if database_name
         end
 
+        NEWLINE = "\n".freeze
+
+        def add_backtrace_parameter
+           return unless duration >= Agent.config[:'transaction_tracer.stack_trace_threshold']
+           params[:backtrace] = caller.join(NEWLINE)
+        end
+
         def notice_sql_statement
-          NewRelic::Agent.instance.transaction_sampler.notice_sql_statement(sql_statement, duration)
+          params[:sql] = sql_statement
           NewRelic::Agent.instance.sql_sampler.notice_sql_statement(sql_statement.dup, name, duration)
-          nil
         end
 
         def notice_statement
-          NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(nosql_statement, duration)
-          nil
+          params[:statement] = nosql_statement
         end
 
         def record_sql?

data/lib/new_relic/agent/transaction/external_request_segment.rb

@@ -83,11 +83,12 @@ module NewRelic
         private
 
         def segment_complete
-          node_params = {:uri => HTTPClients::URIUtil.filter_uri(uri)}
+          params[:uri] = HTTPClients::URIUtil.filter_uri(uri)
           if cross_app_request?
-            node_params[:transaction_guid] = transaction_guid
+            params[:transaction_guid] = transaction_guid
           end
-          Agent.instance.transaction_sampler.add_node_parameters node_params
+
+          super
         end
 
         def process_host_header request

data/lib/new_relic/agent/transaction/segment.rb

@@ -19,11 +19,37 @@ module NewRelic
         end
 
         def record_metrics
-          metric_cache.record_scoped_and_unscoped name, duration, exclusive_duration
+          if record_scoped_metric?
+            metric_cache.record_scoped_and_unscoped name, duration, exclusive_duration
+          else
+            append_unscoped_metric name
+          end
           if unscoped_metrics
             metric_cache.record_unscoped unscoped_metrics, duration, exclusive_duration
           end
         end
+
+        private
+
+        def append_unscoped_metric metric
+          if @unscoped_metrics
+            if Array === @unscoped_metrics
+              if unscoped_metrics.frozen?
+                @unscoped_metrics += [name]
+              else
+                @unscoped_metrics << name
+              end
+            else
+              @unscoped_metrics = [@unscoped_metrics, metric]
+            end
+          else
+            @unscoped_metrics = metric
+          end
+        end
+
+        def segment_complete
+          Agent.instance.transaction_sampler.add_node_parameters params if params?
+        end
       end
     end
   end