newrelic_rpm 3.11.2.286 → 3.12.0.288

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

@@ -86,8 +86,8 @@ module NewRelic
         end
 
         # When pushing a scope different sample buffers potentially want to
-        # know about what's happening to annotate the incoming segments
-        def visit_segment(*)
+        # know about what's happening to annotate the incoming nodes
+        def visit_node(*)
           # no-op
         end
 

data/lib/new_relic/agent/transaction_event_aggregator.rb

@@ -32,6 +32,9 @@ class NewRelic::Agent::TransactionEventAggregator
   SYNTHETICS_JOB_ID_KEY          = "nr.syntheticsJobId".freeze
   SYNTHETICS_MONITOR_ID_KEY      = "nr.syntheticsMonitorId".freeze
 
+  # To avoid allocations when we have empty custom or agent attributes
+  EMPTY_HASH = {}.freeze
+
   def initialize( event_listener )
     super()
 
@@ -143,10 +146,12 @@ class NewRelic::Agent::TransactionEventAggregator
   def on_transaction_finished(payload)
     return unless @enabled
 
+    attributes = payload[:attributes]
     main_event = create_main_event(payload)
-    custom_params = create_custom_parameters(payload)
+    custom_attributes = create_custom_attributes(attributes)
+    agent_attributes  = create_agent_attributes(attributes)
 
-    self.synchronize { append_event([main_event, custom_params]) }
+    self.synchronize { append_event([main_event, custom_attributes, agent_attributes]) }
     notify_full if !@notified_full && @samples.full?
   end
 
@@ -246,12 +251,23 @@ class NewRelic::Agent::TransactionEventAggregator
     end
   end
 
-  def create_custom_parameters(payload)
-    custom_params = {}
-    if ::NewRelic::Agent.config[:'analytics_events.capture_attributes']
-      custom_params.merge!(event_params(payload[:custom_params] || {}))
+  def create_custom_attributes(attributes)
+    if attributes
+      custom_attributes = attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS)
+      custom_attributes = custom_attributes
+      custom_attributes.freeze
+    else
+      EMPTY_HASH
     end
-    custom_params
   end
 
+  def create_agent_attributes(attributes)
+    if attributes
+      agent_attributes = attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS)
+      agent_attributes = agent_attributes
+      agent_attributes.freeze
+    else
+      EMPTY_HASH
+    end
+  end
 end

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -3,9 +3,10 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/collection_helper'
-require 'new_relic/transaction_sample'
 require 'new_relic/control'
 require 'new_relic/agent/transaction'
+require 'new_relic/agent/transaction/trace'
+
 module NewRelic
   module Agent
     # a builder is created with every sampled transaction, to dynamically
@@ -15,25 +16,25 @@ module NewRelic
     # @api private
     class TransactionSampleBuilder
 
-      # Once we hit the TT segment limit, we use this class to hold our place in
+      # Once we hit the TT node limit, we use this class to hold our place in
       # the tree so that we can still get accurate names and times on the
-      # segments we've already created. The placeholder segment keeps a
-      # depth counter that's incremented on each segment entry, and decremented
+      # nodes we've already created. The placeholder node keeps a
+      # depth counter that's incremented on each node entry, and decremented
       # on exit, until it reaches zero, when we throw the placeholder away.
-      # There should only ever be zero or one placeholder segment at a time.
+      # There should only ever be zero or one placeholder node at a time.
       #
       # @api private
-      class PlaceholderSegment
-        attr_reader :parent_segment
+      class PlaceholderNode
+        attr_reader :parent_node
         attr_accessor :depth
 
-        def initialize(parent_segment)
-          @parent_segment = parent_segment
+        def initialize(parent_node)
+          @parent_node = parent_node
           @depth = 1
         end
 
         # No-op - some clients expect to be able to use these to read/write
-        # params on TT segments.
+        # params on TT nodes.
         def [](key); end
         def []=(key, value); end
 
@@ -42,14 +43,14 @@ module NewRelic
         def params=; end
       end
 
-      attr_reader :current_segment, :sample
+      attr_reader :current_node, :sample
 
       include NewRelic::CollectionHelper
 
       def initialize(time=Time.now)
-        @sample = NewRelic::TransactionSample.new(time.to_f)
+        @sample = NewRelic::Agent::Transaction::Trace.new(time.to_f)
         @sample_start = time.to_f
-        @current_segment = @sample.root_segment
+        @current_node = @sample.root_node
       end
 
       def sample_id
@@ -64,58 +65,53 @@ module NewRelic
         @ignore = true
       end
 
-      def segment_limit
+      def node_limit
         Agent.config[:'transaction_tracer.limit_segments']
       end
 
       def trace_entry(time)
-        if @sample.count_segments < segment_limit
-          segment = @sample.create_segment(time.to_f - @sample_start)
-          @current_segment.add_called_segment(segment)
-          @current_segment = segment
-          if @sample.count_segments == segment_limit()
-            ::NewRelic::Agent.logger.debug("Segment limit of #{segment_limit} reached, ceasing collection.")
+        if @sample.count_nodes < node_limit
+          node = @sample.create_node(time.to_f - @sample_start)
+          @current_node.add_called_node(node)
+          @current_node = node
+          if @sample.count_nodes == node_limit()
+            ::NewRelic::Agent.logger.debug("Node limit of #{node_limit} reached, ceasing collection.")
           end
         else
-          if @current_segment.is_a?(PlaceholderSegment)
-            @current_segment.depth += 1
+          if @current_node.is_a?(PlaceholderNode)
+            @current_node.depth += 1
           else
-            @current_segment = PlaceholderSegment.new(@current_segment)
+            @current_node = PlaceholderNode.new(@current_node)
           end
         end
-        @current_segment
+        @current_node
       end
 
       def trace_exit(metric_name, time)
-        if @current_segment.is_a?(PlaceholderSegment)
-          @current_segment.depth -= 1
-          if @current_segment.depth == 0
-            @current_segment = @current_segment.parent_segment
+        if @current_node.is_a?(PlaceholderNode)
+          @current_node.depth -= 1
+          if @current_node.depth == 0
+            @current_node = @current_node.parent_node
           end
         else
-          @current_segment.metric_name = metric_name
-          @current_segment.end_trace(time.to_f - @sample_start)
-          @current_segment = @current_segment.parent_segment
+          @current_node.metric_name = metric_name
+          @current_node.end_trace(time.to_f - @sample_start)
+          @current_node = @current_node.parent_node
         end
       end
 
-      def finish_trace(time=Time.now.to_f, custom_params={})
+      def finish_trace(time=Time.now.to_f)
         # Should never get called twice, but in a rare case that we can't
         # reproduce in house it does.  log forensics and return gracefully
         if @sample.finished
           ::NewRelic::Agent.logger.error "Unexpected double-finish_trace of Transaction Trace Object: \n#{@sample.to_s}"
           return
         end
-        @sample.root_segment.end_trace(time.to_f - @sample_start)
-        @sample.params[:custom_params] ||= {}
-        @sample.params[:custom_params].merge!(normalize_params(custom_params))
+        @sample.root_node.end_trace(time.to_f - @sample_start)
 
-        # If we ever implement saving of TTs based on the record_tt flag on the
-        # calling and called applications, we should change this flag's value.
-        @sample.force_persist = false
         @sample.threshold = transaction_trace_threshold
         @sample.finished = true
-        @current_segment = nil
+        @current_node = nil
       end
 
       TT_THRESHOLD_KEY = :'transaction_tracer.transaction_threshold'
@@ -132,37 +128,16 @@ module NewRelic
 
       def scope_depth
         depth = -1        # have to account for the root
-        current = @current_segment
+        current = @current_node
 
         while(current)
           depth += 1
-          current = current.parent_segment
+          current = current.parent_node
         end
 
         depth
       end
 
-      def set_transaction_uri(uri)
-        @sample.params[:uri] ||= uri
-      end
-
-      def set_request_params(params)
-        if Agent.config[:capture_params]
-          params = normalize_params(params)
-          @sample.params[:request_params].merge!(params)
-          @sample.params[:request_params].delete :controller
-          @sample.params[:request_params].delete :action
-        end
-      end
-
-      def set_transaction_name(name)
-        @sample.transaction_name = name
-      end
-
-      def set_transaction_cpu_time(cpu_time)
-        @sample.set_custom_param(:cpu_time, cpu_time)
-      end
-
       def sample
         @sample
       end

data/lib/new_relic/agent/transaction_sampler.rb

@@ -6,7 +6,6 @@ require 'new_relic/agent'
 require 'new_relic/control'
 require 'new_relic/agent/transaction_sample_builder'
 require 'new_relic/agent/transaction/developer_mode_sample_buffer'
-require 'new_relic/agent/transaction/force_persist_sample_buffer'
 require 'new_relic/agent/transaction/slowest_sample_buffer'
 require 'new_relic/agent/transaction/synthetics_sample_buffer'
 require 'new_relic/agent/transaction/xray_sample_buffer'
@@ -43,7 +42,6 @@ module NewRelic
         @sample_buffers << @xray_sample_buffer
         @sample_buffers << NewRelic::Agent::Transaction::SlowestSampleBuffer.new
         @sample_buffers << NewRelic::Agent::Transaction::SyntheticsSampleBuffer.new
-        @sample_buffers << NewRelic::Agent::Transaction::ForcePersistSampleBuffer.new
 
         # This lock is used to synchronize access to the @last_sample
         # and related variables. It can become necessary on JRuby or
@@ -70,28 +68,27 @@ module NewRelic
         Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
       end
 
-      def on_start_transaction(state, start_time, uri=nil)
+      def on_start_transaction(state, start_time)
         if enabled?
           start_builder(state, start_time.to_f)
           builder = state.transaction_sample_builder
-          builder.set_transaction_uri(uri) if builder
         end
       end
 
-      # This delegates to the builder to create a new open transaction segment
+      # This delegates to the builder to create a new open transaction node
       # for the frame, beginning at the optionally specified time.
       #
       # Note that in developer mode, this captures a stacktrace for
-      # the beginning of each segment, which can be fairly slow
+      # the beginning of each node, which can be fairly slow
       def notice_push_frame(state, time=Time.now)
         builder = state.transaction_sample_builder
         return unless builder
 
-        segment = builder.trace_entry(time.to_f)
+        node = builder.trace_entry(time.to_f)
         if @dev_mode_sample_buffer
-          @dev_mode_sample_buffer.visit_segment(segment)
+          @dev_mode_sample_buffer.visit_node(node)
         end
-        segment
+        node
       end
 
       # Informs the transaction sample builder about the end of a traced frame
@@ -102,14 +99,6 @@ module NewRelic
         builder.trace_exit(frame, time.to_f)
       end
 
-      def custom_parameters_from_transaction(txn)
-        if Agent.config[:'transaction_tracer.capture_attributes']
-          txn.custom_parameters
-        else
-          {}
-        end
-      end
-
       # This is called when we are done with the transaction.  We've
       # unwound the stack to the top level. It also clears the
       # transaction sample builder so that it won't continue to have
@@ -117,33 +106,20 @@ module NewRelic
       #
       # It sets various instance variables to the finished sample,
       # depending on which settings are active. See `store_sample`
-      def on_finishing_transaction(state, txn, time=Time.now, gc_time=nil)
+      def on_finishing_transaction(state, txn, time=Time.now)
         last_builder = state.transaction_sample_builder
         return unless last_builder && enabled?
 
         state.transaction_sample_builder = nil
-        return if last_builder.ignored?
+        return if txn.ignore_trace?
 
-        last_builder.set_request_params(txn.filtered_params)
-        last_builder.set_transaction_name(txn.best_name)
-        last_builder.finish_trace(time.to_f, custom_parameters_from_transaction(txn))
+        last_builder.finish_trace(time.to_f)
 
         last_sample = last_builder.sample
+        last_sample.transaction_name = txn.best_name
+        last_sample.uri = txn.request_path
         last_sample.guid = txn.guid
-        last_sample.set_custom_param(:gc_time, gc_time) if gc_time
-
-        if state.is_cross_app?
-          last_sample.set_custom_param(:'nr.trip_id', txn.cat_trip_id(state))
-          last_sample.set_custom_param(:'nr.path_hash', txn.cat_path_hash(state))
-        end
-
-        if txn.is_synthetics_request?
-          last_sample.set_custom_param(:'nr.synthetics_resource_id', txn.synthetics_resource_id)
-          last_sample.set_custom_param(:'nr.synthetics_job_id', txn.synthetics_job_id)
-          last_sample.set_custom_param(:'nr.synthetics_monitor_id', txn.synthetics_monitor_id)
-
-          last_sample.synthetics_resource_id = txn.synthetics_resource_id
-        end
+        last_sample.attributes = txn.attributes
 
         @samples_lock.synchronize do
           @last_sample = last_sample
@@ -158,42 +134,27 @@ module NewRelic
         end
       end
 
-      # Tells the builder to ignore a transaction, if we are currently
-      # creating one. Only causes the sample to be ignored upon end of
-      # the transaction, and does not change the metrics gathered
-      # outside of the sampler
-      def ignore_transaction(state)
-        builder = state.transaction_sample_builder
-        builder.ignore_transaction if builder
-      end
-
-      # Sets the CPU time used by a transaction, delegates to the builder
-      def notice_transaction_cpu_time(state, cpu_time)
-        builder = state.transaction_sample_builder
-        builder.set_transaction_cpu_time(cpu_time) if builder
-      end
-
       MAX_DATA_LENGTH = 16384
       # This method is used to record metadata into the currently
-      # active segment like a sql query, memcache key, or Net::HTTP uri
+      # active node like a sql query, memcache key, or Net::HTTP uri
       #
       # duration is seconds, float value.
       def notice_extra_data(builder, message, duration, key)
         return unless builder
-        segment = builder.current_segment
-        if segment
+        node = builder.current_node
+        if node
           if key == :sql
-            sql = segment[:sql]
+            sql = node[:sql]
             if(sql && !sql.empty?)
               sql = self.class.truncate_message(sql << "\n#{message}") if sql.length <= MAX_DATA_LENGTH
             else
               # message is expected to have been pre-truncated by notice_sql
-              segment[:sql] = message
+              node[:sql] = message
             end
           else
-            segment[key] = self.class.truncate_message(message)
+            node[key] = self.class.truncate_message(message)
           end
-          append_backtrace(segment, duration)
+          append_backtrace(node, duration)
         end
       end
 
@@ -211,15 +172,15 @@ module NewRelic
         end
       end
 
-      # Appends a backtrace to a segment if that segment took longer
+      # Appends a backtrace to a node if that node took longer
       # than the specified duration
-      def append_backtrace(segment, duration)
+      def append_backtrace(node, duration)
         if duration >= Agent.config[:'transaction_tracer.stack_trace_threshold']
-          segment[:backtrace] = caller.join("\n")
+          node[:backtrace] = caller.join("\n")
         end
       end
 
-      # Attaches an SQL query on the current transaction trace segment.
+      # Attaches an SQL query on the current transaction trace node.
       #
       # This method should be used only by gem authors wishing to extend
       # the Ruby agent to instrument new database interfaces - it should
@@ -232,6 +193,7 @@ module NewRelic
       #                         not pass this parameter.
       #
       # @api public
+      # @deprecated Use {Datastores.notice_sql} instead.
       #
       def notice_sql(sql, config, duration, state=nil, &explainer) #THREAD_LOCAL_ACCESS sometimes
         # some statements (particularly INSERTS with large BLOBS
@@ -256,7 +218,7 @@ module NewRelic
       end
 
       # Attaches an additional non-SQL query parameter to the current
-      # transaction trace segment.
+      # transaction trace node.
       #
       # This may be used for recording a query against a key-value store like
       # memcached or redis.
@@ -269,6 +231,7 @@ module NewRelic
       # @param duration [Float] number of seconds the query took to execute
       #
       # @api public
+      # @deprecated Use {Datastores.notice_statement} instead.
       #
       def notice_nosql(key, duration) #THREAD_LOCAL_ACCESS
         builder = tl_builder
@@ -280,11 +243,11 @@ module NewRelic
         notice_extra_data(builder, statement, duration, :statement)
       end
 
-      # Set parameters on the current segment.
-      def add_segment_parameters(params) #THREAD_LOCAL_ACCESS
+      # Set parameters on the current node.
+      def add_node_parameters(params) #THREAD_LOCAL_ACCESS
         builder = tl_builder
         return unless builder
-        params.each { |k,v| builder.current_segment[k] = v }
+        params.each { |k,v| builder.current_node[k] = v }
       end
 
       # Gather transaction traces that we'd like to transmit to the server.