newrelic_rpm 5.5.0.348 → 6.2.0.354

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

@@ -228,7 +228,7 @@ module NewRelic
           @transaction_state ||= if @transaction
             transaction.state
           else
-            TransactionState.tl_get
+            Tracer.state
           end
         end
       end

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

@@ -109,13 +109,11 @@ module NewRelic
         end
 
         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
-          return unless NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
           params[:database_name] = database_name if database_name
         end
 

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

@@ -156,8 +156,7 @@ module NewRelic
             !payload.parent_type.nil? &&
             (!payload.transaction_id.nil? || !payload.id.nil?) &&
             !payload.trace_id.nil? &&
-            !payload.timestamp.nil? &&
-            !payload.parent_account_id.nil?
+            !payload.timestamp.nil?
 
             true
           else

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

@@ -21,8 +21,10 @@ module NewRelic
           @entry_timestamp = relative_start
           @metric_name     = metric_name || UNKNOWN_NODE_NAME
           @exit_timestamp  = relative_end
-          @children    = nil
-          @params          = params
+          @children        = nil
+          @params          = params.select do |p|
+            NewRelic::Agent.instance.attribute_filter.allows_key? p, AttributeFilter::DST_TRANSACTION_SEGMENTS
+          end if params
           @parent_node     = parent
         end
 

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

@@ -2,109 +2,10 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-require 'new_relic/agent/transaction/segment'
-require 'new_relic/agent/transaction/datastore_segment'
-require 'new_relic/agent/transaction/external_request_segment'
-require 'new_relic/agent/transaction/message_broker_segment'
-
 module NewRelic
   module Agent
     class Transaction
       module Tracing
-        module ClassMethods
-          def start_segment(name:nil,
-                            unscoped_metrics:nil,
-                            start_time: nil,
-                            parent: nil)
-
-            # ruby 2.0.0 does not support required kwargs
-            raise ArgumentError, 'missing required argument: name' if name.nil?
-
-            segment = Segment.new name, unscoped_metrics, start_time
-
-            start_and_add_segment segment, parent
-          end
-
-          UNKNOWN_PRODUCT = "Unknown".freeze
-          UNKNOWN_OPERATION = "other".freeze
-
-          def start_datastore_segment(product: nil,
-                                      operation: nil,
-                                      collection: nil,
-                                      host: nil,
-                                      port_path_or_id: nil,
-                                      database_name: nil,
-                                      start_time: nil,
-                                      parent: nil)
-
-            product ||= UNKNOWN_PRODUCT
-            operation ||= UNKNOWN_OPERATION
-
-            segment = DatastoreSegment.new product, operation, collection, host, port_path_or_id, database_name
-            start_and_add_segment segment, parent
-          end
-
-          def start_external_request_segment(library: nil,
-                                             uri: nil,
-                                             procedure: nil,
-                                             start_time: nil,
-                                             parent: nil)
-
-            # ruby 2.0.0 does not support required kwargs
-            raise ArgumentError, 'missing required argument: library' if library.nil?
-            raise ArgumentError, 'missing required argument: uri' if uri.nil?
-            raise ArgumentError, 'missing required argument: procedure' if procedure.nil?
-
-            segment = ExternalRequestSegment.new library, uri, procedure, start_time
-            start_and_add_segment segment, parent
-          end
-
-          # @api private
-          #
-          def start_message_broker_segment(action: nil,
-                                           library: nil,
-                                           destination_type: nil,
-                                           destination_name: nil,
-                                           headers: nil,
-                                           parameters: nil,
-                                           start_time: nil,
-                                           parent: nil)
-
-            # ruby 2.0.0 does not support required kwargs
-            raise ArgumentError, 'missing required argument: action' if action.nil?
-            raise ArgumentError, 'missing required argument: library' if library.nil?
-            raise ArgumentError, 'missing required argument: destination_type' if destination_type.nil?
-            raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
-
-            segment = MessageBrokerSegment.new(
-              action: action,
-              library: library,
-              destination_type: destination_type,
-              destination_name: destination_name,
-              headers: headers,
-              parameters: parameters,
-              start_time: start_time
-            )
-            start_and_add_segment segment, parent
-          end
-
-          private
-
-          def start_and_add_segment segment, parent = nil
-            state = NewRelic::Agent::TransactionState.tl_get
-            if (txn = state.current_transaction) && state.is_execution_traced?
-              txn.add_segment segment, parent
-            else
-              segment.record_metrics = false
-            end
-            segment.start
-            segment
-          end
-        end
-
-        def self.included base
-          base.extend ClassMethods
-        end
 
         attr_reader :current_segment
 

data/lib/new_relic/agent/transaction.rb

@@ -11,6 +11,7 @@ require 'new_relic/agent/transaction/tracing'
 require 'new_relic/agent/transaction/distributed_tracing'
 require 'new_relic/agent/cross_app_tracing'
 require 'new_relic/agent/transaction_time_aggregator'
+require 'new_relic/agent/deprecator'
 
 module NewRelic
   module Agent
@@ -36,7 +37,7 @@ module NewRelic
       ACTION_CABLE_PREFIX          = 'Controller/ActionCable/'.freeze
       OTHER_TRANSACTION_PREFIX     = 'OtherTransaction/'.freeze
 
-      WEB_TRANSACTION_CATEGORIES   = [:controller, :uri, :rack, :sinatra, :grape, :middleware, :action_cable].freeze
+      WEB_TRANSACTION_CATEGORIES   = [:web, :controller, :uri, :rack, :sinatra, :grape, :middleware, :action_cable].freeze
       TRANSACTION_NAMING_SOURCES   = [:child, :api].freeze
 
       MIDDLEWARE_SUMMARY_METRICS   = ['Middleware/all'.freeze].freeze
@@ -64,7 +65,6 @@ module NewRelic
                   :metrics,
                   :gc_start_snapshot,
                   :category,
-                  :frame_stack,
                   :attributes,
                   :payload,
                   :nesting_max_depth,
@@ -83,28 +83,37 @@ module NewRelic
 
       # Return the currently active transaction, or nil.
       def self.tl_current
-        TransactionState.tl_get.current_transaction
+        Tracer.current_transaction
       end
 
-      def self.set_default_transaction_name(name, category = nil, node_name = nil) #THREAD_LOCAL_ACCESS
+      def self.set_default_transaction_name(partial_name, category = nil) #THREAD_LOCAL_ACCESS
         txn  = tl_current
-        name = txn.make_transaction_name(name, category)
-        txn.name_last_frame(node_name || name)
+        name = name_from_partial(partial_name, category || txn.category)
         txn.set_default_transaction_name(name, category)
       end
 
-      def self.set_overriding_transaction_name(name, category = nil) #THREAD_LOCAL_ACCESS
+      def self.set_overriding_transaction_name(partial_name, category = nil) #THREAD_LOCAL_ACCESS
         txn = tl_current
         return unless txn
 
-        name = txn.make_transaction_name(name, category)
-
-        txn.name_last_frame(name)
+        name = name_from_partial(partial_name, category || txn.category)
         txn.set_overriding_transaction_name(name, category)
       end
 
+      def self.name_from_partial(partial_name, category)
+        namer = Instrumentation::ControllerInstrumentation::TransactionNamer
+        "#{namer.prefix_for_category(self, category)}#{partial_name}"
+      end
+
       def self.wrap(state, name, category, options = {})
-        Transaction.start(state, category, options.merge(:transaction_name => name))
+        Deprecator.deprecate 'Transaction.wrap',
+                             'Tracer#in_transaction'
+
+        finishable = Tracer.start_transaction_or_segment(
+              name: name,
+              category: category,
+              options: options
+            )
 
         begin
           # We shouldn't raise from Transaction.start, but only wrap the yield
@@ -114,24 +123,8 @@ module NewRelic
           Transaction.notice_error(e)
           raise e
         ensure
-          Transaction.stop(state)
-        end
-      end
-
-      def self.start(state, category, options)
-        category ||= :controller
-        txn = state.current_transaction
-
-        if txn
-          txn.create_nested_frame(category, options)
-        else
-          txn = start_new_transaction(state, category, options)
+          finishable.finish if finishable
         end
-
-        txn
-      rescue => e
-        NewRelic::Agent.logger.error("Exception during Transaction.start", e)
-        nil
       end
 
       def self.start_new_transaction(state, category, options)
@@ -142,32 +135,6 @@ module NewRelic
         txn
       end
 
-      FAILED_TO_STOP_MESSAGE = "Failed during Transaction.stop because there is no current transaction"
-
-      def self.stop(state)
-        txn = state.current_transaction
-
-        if txn.nil?
-          NewRelic::Agent.logger.error(FAILED_TO_STOP_MESSAGE)
-          return
-        end
-
-        nested_frame = txn.frame_stack.pop
-
-        if txn.frame_stack.empty?
-          txn.stop(nested_frame) if nested_frame
-          state.reset
-        else
-          nested_frame.finish
-        end
-
-        :transaction_stopped
-      rescue => e
-        state.reset
-        NewRelic::Agent.logger.error("Exception during Transaction.stop", e)
-        nil
-      end
-
       def self.nested_transaction_name(name)
         if name.start_with?(CONTROLLER_PREFIX) || name.start_with?(OTHER_TRANSACTION_PREFIX)
           "#{SUBTRANSACTION_PREFIX}#{name}"
@@ -179,15 +146,13 @@ module NewRelic
       # Indicate that you don't want to keep the currently saved transaction
       # information
       def self.abort_transaction! #THREAD_LOCAL_ACCESS
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
+        txn = Tracer.current_transaction
         txn.abort_transaction! if txn
       end
 
       # See NewRelic::Agent.notice_error for options and commentary
       def self.notice_error(e, options={}) #THREAD_LOCAL_ACCESS
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
+        txn = Tracer.current_transaction
         if txn
           txn.notice_error(e, options)
         elsif NewRelic::Agent.instance
@@ -260,7 +225,6 @@ module NewRelic
         @nesting_max_depth = 0
         @current_segment = nil
         @segments = []
-        @frame_stack = []
 
         self.default_name = options[:transaction_name]
         @overridden_name    = nil
@@ -288,6 +252,8 @@ module NewRelic
         @sampled = nil
         @priority = nil
 
+        @starting_thread_id = Thread.current.object_id
+
         @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
 
         merge_request_parameters(@filtered_params)
@@ -357,11 +323,6 @@ module NewRelic
         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}"
-      end
-
       def set_default_transaction_name(name, category)
         return log_frozen_name(name) if name_frozen?
         if influences_transaction_name?(category)
@@ -378,18 +339,13 @@ module NewRelic
         end
       end
 
-      def name_last_frame(name)
-        name = self.class.nested_transaction_name(name) if nesting_max_depth > 1
-        frame_stack.last.name = name
-      end
-
       def log_frozen_name(name)
         NewRelic::Agent.logger.warn("Attempted to rename transaction to '#{name}' after transaction name was already frozen as '#{@frozen_name}'.")
         nil
       end
 
       def influences_transaction_name?(category)
-        !category || frame_stack.size == 1 || similar_category?(category)
+        !category || nesting_max_depth == 1 || similar_category?(category)
       end
 
       def best_name
@@ -403,10 +359,6 @@ module NewRelic
       attr_accessor :xray_session_id
       # End common interface
 
-      def name_set?
-        (@overridden_name || @default_name) ? true : false
-      end
-
       def promoted_transaction_name(name)
         if name.start_with?(MIDDLEWARE_PREFIX)
           "#{CONTROLLER_PREFIX}#{name}"
@@ -447,14 +399,14 @@ module NewRelic
 
         ignore! if user_defined_rules_ignore?
 
-        create_initial_segment @default_name
+        create_initial_segment
       end
 
       def initial_segment
         segments.first
       end
 
-      def create_initial_segment name
+      def create_initial_segment
         segment = create_segment @default_name
         segment.record_scoped_metric = false
       end
@@ -468,16 +420,15 @@ module NewRelic
 
         @nesting_max_depth += 1
 
-        segment = self.class.start_segment(
+        segment = Tracer.start_segment(
           name: name,
           unscoped_metrics: summary_metrics
         )
 
-        frame_stack.push segment
         segment
       end
 
-      def create_nested_frame(category, options)
+      def create_nested_segment(category, options)
         if options[:filtered_params] && !options[:filtered_params].empty?
           @filtered_params = options[:filtered_params]
           merge_request_parameters(options[:filtered_params])
@@ -488,8 +439,9 @@ module NewRelic
 
         nest_initial_segment if nesting_max_depth == 1
         nested_name = self.class.nested_transaction_name options[:transaction_name]
-        create_segment nested_name
+        result = create_segment nested_name
         set_default_transaction_name(options[:transaction_name], category)
+        result
       end
 
       def nest_initial_segment
@@ -527,23 +479,26 @@ module NewRelic
         name.start_with?(MIDDLEWARE_PREFIX)
       end
 
-      def stop(outermost_frame = nil)
-        return if !state.is_execution_traced?
-        return self.class.stop(state) unless outermost_frame
-
+      def finish
+        return unless state.is_execution_traced?
         @end_time = Time.now
         @duration = @end_time.to_f - @start_time.to_f
         freeze_name_and_execute_if_not_ignored
 
         if nesting_max_depth == 1
-          outermost_frame.name = @frozen_name
+          initial_segment.name = @frozen_name
         end
 
-        outermost_frame.finish
+        initial_segment.finish
 
-        NewRelic::Agent::TransactionTimeAggregator.transaction_stop(@end_time)
+        NewRelic::Agent::TransactionTimeAggregator.transaction_stop(@end_time, @starting_thread_id)
 
-        commit!(outermost_frame.name) unless @ignore_this_transaction
+        commit!(initial_segment.name) unless @ignore_this_transaction
+      rescue => e
+        NewRelic::Agent.logger.error("Exception during Transaction#finish", e)
+        nil
+      ensure
+        state.reset
       end
 
       def user_defined_rules_ignore?

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -2,8 +2,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-require 'objspace'
-
 # This module powers the Busy calculation for the Capacity report in
 # APM (https://rpm.newrelic.com/accounts/.../applications/.../optimize/capacity_analysis).
 #
@@ -23,37 +21,37 @@ module NewRelic
         h[k] = TransactionStats.new nil, 0.0
       end
 
-      def reset!(now = Time.now)
-        @harvest_cycle_started_at = now
+      def reset!(timestamp = Time.now)
+        @harvest_cycle_started_at = timestamp
         @stats.clear
       end
 
-      def transaction_start(now = Time.now)
+      def transaction_start(timestamp = Time.now)
         @lock.synchronize do
-          set_transaction_start_time now
+          set_transaction_start_time timestamp
         end
       end
 
-      def transaction_stop(now = Time.now)
+      def transaction_stop(timestamp = Time.now, starting_thread_id = current_thread)
         @lock.synchronize do
-          record_elapsed_transaction_time_until now
-          set_transaction_start_time nil
+          record_elapsed_transaction_time_until timestamp, starting_thread_id
+          set_transaction_start_time nil, starting_thread_id
         end
       end
 
       INSTANCE_BUSY_METRIC = 'Instance/Busy'.freeze
 
-      def harvest!(now = Time.now)
+      def harvest!(timestamp = Time.now)
         active_threads = 0
         result = @lock.synchronize do
           # Sum up the transaction times spent in each thread
           elapsed_transaction_time = @stats.inject(0.0) do |total, (thread_id, entry)|
-            total + transaction_time_in_thread(thread_id, entry, now)
+            total + transaction_time_in_thread(timestamp, thread_id, entry)
           end
 
           active_threads = @stats.size
-          elapsed_harvest_time      = (now - @harvest_cycle_started_at) * active_threads
-          @harvest_cycle_started_at = now
+          elapsed_harvest_time      = (timestamp - @harvest_cycle_started_at) * active_threads
+          @harvest_cycle_started_at = timestamp
 
           # Clear out the stats for all threads, _except_ the live ones
           # that have transactions still open (we'll count the rest of
@@ -81,12 +79,16 @@ module NewRelic
                       :transaction_stop,
                       :harvest!
 
-      class <<self
+      class << self
         private
 
-        def record_elapsed_transaction_time_until(timestamp, thread_id: current_thread)
-          @stats[thread_id].elapsed_transaction_time +=
-            (timestamp - (@stats[thread_id].transaction_started_at || 0.0))
+        def record_elapsed_transaction_time_until(timestamp, thread_id = current_thread)
+          if @stats[thread_id].transaction_started_at
+            @stats[thread_id].elapsed_transaction_time +=
+              (timestamp - (@stats[thread_id].transaction_started_at || 0.0))
+          else
+            log_missing_elapsed_transaction_time
+          end
         end
 
         def in_transaction?(thread_id = current_thread)
@@ -98,33 +100,55 @@ module NewRelic
         end
 
         def thread_is_alive?(thread_id)
-          thread = ObjectSpace._id2ref(thread_id)
+          thread = thread_by_id thread_id
           thread && thread.alive?
         rescue StandardError
           false
         end
 
-        def set_transaction_start_time(timestamp)
-          @stats[current_thread].transaction_started_at = timestamp
+        # ObjectSpace is faster on MRI, but disabled by default on JRuby for
+        # perfomance reasons. We have two implmentations of `thread_by_id`
+        # based on ruby implementation.
+        if RUBY_ENGINE == 'jruby'
+          def thread_by_id thread_id
+            Thread.list.detect { |t| t.object_id == thread_id }
+          end
+        else
+          require 'objspace'
+
+          def thread_by_id thread_id
+            ObjectSpace._id2ref(thread_id)
+          end
+        end
+
+        def set_transaction_start_time(timestamp, thread_id = current_thread)
+          @stats[thread_id].transaction_started_at = timestamp
         end
 
-        def split_transaction_at_harvest(now, thread_id: nil)
+        def split_transaction_at_harvest(timestamp, thread_id = nil)
           raise ArgumentError, 'thread_id required' unless thread_id
-          @stats[thread_id].transaction_started_at = now
+          @stats[thread_id].transaction_started_at = timestamp
           @stats[thread_id].elapsed_transaction_time = 0.0
         end
 
-        def transaction_time_in_thread thread_id, entry, now
+        def transaction_time_in_thread timestamp, thread_id, entry
           return entry.elapsed_transaction_time unless in_transaction? thread_id
 
           # Count the portion of the transaction that's elapsed so far,...
-          elapsed = record_elapsed_transaction_time_until now, thread_id: thread_id
+          elapsed = record_elapsed_transaction_time_until timestamp, thread_id
 
           # ...then readjust the transaction start time to the next harvest
-          split_transaction_at_harvest now, thread_id: thread_id
+          split_transaction_at_harvest timestamp, thread_id
 
           elapsed
         end
+
+        def log_missing_elapsed_transaction_time
+          transaction_name = Tracer.current_transaction &&
+            Tracer.current_transaction.best_name ||
+              "unknown"
+          NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
+        end
       end
     end
   end