newrelic_rpm 4.0.0.332 → 6.13.1

data/lib/new_relic/agent/transaction_event_recorder.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 require 'new_relic/agent/transaction_event_aggregator'
 require 'new_relic/agent/synthetics_event_aggregator'
 require 'new_relic/agent/transaction_event_primitive'
@@ -14,9 +14,9 @@ module NewRelic
       attr_reader :transaction_event_aggregator
       attr_reader :synthetics_event_aggregator
 
-      def initialize
-        @transaction_event_aggregator = NewRelic::Agent::TransactionEventAggregator.new
-        @synthetics_event_aggregator = NewRelic::Agent::SyntheticsEventAggregator.new
+      def initialize events
+        @transaction_event_aggregator = NewRelic::Agent::TransactionEventAggregator.new events
+        @synthetics_event_aggregator = NewRelic::Agent::SyntheticsEventAggregator.new events
       end
 
       def record payload
@@ -24,10 +24,10 @@ module NewRelic
 
         if synthetics_event? payload
           event = create_event payload
-          _, rejected = synthetics_event_aggregator.append_or_reject event
-          transaction_event_aggregator.append event if rejected
+          result = synthetics_event_aggregator.record event
+          transaction_event_aggregator.record event: event if result.nil?
         else
-          transaction_event_aggregator.append { create_event(payload) }
+          transaction_event_aggregator.record(priority: payload[:priority]) { create_event(payload) }
         end
       end
 

data/lib/new_relic/agent/transaction_metrics.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 # This class represents a set of metrics that were recorded during a single
 # transaction. Since the name of the transaction is not known until its end, we

data/lib/new_relic/agent/transaction_sampler.rb

@@ -1,12 +1,10 @@
 # encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
-require 'new_relic/agent/transaction_sample_builder'
-require 'new_relic/agent/transaction/developer_mode_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'
+require 'new_relic/agent/transaction/trace_builder'
 
 module NewRelic
   module Agent
@@ -20,15 +18,10 @@ module NewRelic
     #
     # @api public
     class TransactionSampler
-      attr_reader :last_sample, :dev_mode_sample_buffer, :xray_sample_buffer
+      attr_reader :last_sample
 
       def initialize
-        @dev_mode_sample_buffer = NewRelic::Agent::Transaction::DeveloperModeSampleBuffer.new
-        @xray_sample_buffer = NewRelic::Agent::Transaction::XraySampleBuffer.new
-
         @sample_buffers = []
-        @sample_buffers << @dev_mode_sample_buffer
-        @sample_buffers << @xray_sample_buffer
         @sample_buffers << NewRelic::Agent::Transaction::SlowestSampleBuffer.new
         @sample_buffers << NewRelic::Agent::Transaction::SyntheticsSampleBuffer.new
 
@@ -54,64 +47,15 @@ module NewRelic
       end
 
       def enabled?
-        Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
-      end
-
-      def on_start_transaction(state, start_time)
-        if enabled?
-          start_builder(state, start_time.to_f)
-        end
-      end
-
-      # 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 node, which can be fairly slow
-      def notice_push_frame(state, time=Time.now)
-        builder = state.transaction_sample_builder
-        return unless builder
-
-        node = builder.trace_entry(time.to_f)
-        if @dev_mode_sample_buffer
-          @dev_mode_sample_buffer.visit_node(node)
-        end
-        node
-      end
-
-      # Informs the transaction sample builder about the end of a traced frame
-      def notice_pop_frame(state, frame, time = Time.now)
-        builder = state.transaction_sample_builder
-        return unless builder
-        raise "finished already???" if builder.sample.finished
-        builder.trace_exit(frame, time.to_f)
+        Agent.config[:'transaction_tracer.enabled']
       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
-      # frames appended to it.
-      #
-      # 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)
-        last_builder = state.transaction_sample_builder
-        return unless last_builder && enabled?
-
-        state.transaction_sample_builder = nil
-        return if txn.ignore_trace?
-
-        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.attributes = txn.attributes
+      def on_finishing_transaction(txn)
+        return if !enabled? || txn.ignore_trace?
 
         @samples_lock.synchronize do
-          @last_sample = last_sample
-          store_sample(@last_sample)
+          @last_sample = txn
+          store_sample(txn)
           @last_sample
         end
       end
@@ -122,118 +66,6 @@ module NewRelic
         end
       end
 
-      MAX_DATA_LENGTH = 16384
-      # This method is used to record metadata into the currently
-      # 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
-        node = builder.current_node
-        if node
-          if key == :sql
-            statement = node[:sql]
-            if(statement && !statement.sql.empty?)
-              statement.sql = self.class.truncate_message(statement.sql + "\n#{message.sql}") if statement.sql.length <= MAX_DATA_LENGTH
-            else
-              # message is expected to have been pre-truncated by notice_sql
-              node[:sql] = message
-            end
-          else
-            node[key] = self.class.truncate_message(message)
-          end
-          append_backtrace(node, duration)
-        end
-      end
-
-      private :notice_extra_data
-
-      # Truncates the message to `MAX_DATA_LENGTH` if needed, and
-      # appends an ellipsis because it makes the trucation clearer in
-      # the UI
-      def self.truncate_message(message)
-        if message.length > (MAX_DATA_LENGTH - 4)
-          message.slice!(MAX_DATA_LENGTH - 4..message.length)
-          message << "..."
-        else
-          message
-        end
-      end
-
-      # Appends a backtrace to a node if that node took longer
-      # than the specified duration
-      def append_backtrace(node, duration)
-        if duration >= Agent.config[:'transaction_tracer.stack_trace_threshold']
-          node[:backtrace] = caller.join("\n")
-        end
-      end
-
-      # 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
-      # generally not be called directly from application code.
-      #
-      # @param sql [String] the SQL query being recorded
-      # @param config [Object] the driver configuration for the connection
-      # @param duration [Float] number of seconds the query took to execute
-      # @param explainer [Proc] for internal use only - 3rd-party clients must
-      #                         not pass this parameter.
-      #
-      # @api public
-      # @deprecated Use {Datastores.notice_sql} instead.
-      #
-      def notice_sql(sql, config, duration, state=nil, explainer=nil, binds=nil, name=nil) #THREAD_LOCAL_ACCESS sometimes
-        # some statements (particularly INSERTS with large BLOBS
-        # may be very large; we should trim them to a maximum usable length
-        state ||= TransactionState.tl_get
-        builder = state.transaction_sample_builder
-        if state.is_sql_recorded?
-          statement = Database::Statement.new(sql, config, explainer, binds, name)
-          notice_extra_data(builder, statement, duration, :sql)
-        end
-      end
-
-
-      def notice_sql_statement(statement, duration) #THREAD_LOCAL_ACCESS sometimes
-        state ||= TransactionState.tl_get
-        builder = state.transaction_sample_builder
-        notice_extra_data(builder, statement, duration, :sql)
-      end
-
-      # Attaches an additional non-SQL query parameter to the current
-      # transaction trace node.
-      #
-      # This may be used for recording a query against a key-value store like
-      # memcached or redis.
-      #
-      # This method should be used only by gem authors wishing to extend
-      # the Ruby agent to instrument uninstrumented key-value stores - it should
-      # generally not be called directly from application code.
-      #
-      # @param key [String] the name of the key that was queried
-      # @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
-        notice_extra_data(builder, key, duration, :key)
-      end
-
-      def notice_nosql_statement(statement, duration) #THREAD_LOCAL_ACCESS
-        builder = tl_builder
-        notice_extra_data(builder, statement, duration, :statement)
-      end
-
-      # 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_node[k] = v }
-      end
-
       # Gather transaction traces that we'd like to transmit to the server.
       def harvest!
         return [] unless enabled?
@@ -279,7 +111,14 @@ module NewRelic
         # know, Ruby 1.8.6 :/
         result = []
         @sample_buffers.each { |buffer| result.concat(buffer.harvest_samples) }
-        result.uniq
+        result.uniq!
+        result.map! do |sample|
+          if Transaction === sample
+            Transaction::TraceBuilder.build_trace sample
+          else
+            sample
+          end
+        end
       end
 
       # reset samples without rebooting the web server (used by dev mode)
@@ -289,25 +128,6 @@ module NewRelic
           @sample_buffers.each { |sample_buffer| sample_buffer.reset! }
         end
       end
-
-      # Checks to see if the transaction sampler is disabled, if
-      # transaction trace recording is disabled by a thread local, or
-      # if execution is untraced - if so it clears the transaction
-      # sample builder from the thread local, otherwise it generates a
-      # new transaction sample builder with the stated time as a
-      # starting point and saves it in the thread local variable
-      def start_builder(state, time=nil)
-        if !enabled? || !state.is_transaction_traced? || !state.is_execution_traced?
-          state.transaction_sample_builder = nil
-        else
-          state.transaction_sample_builder ||= TransactionSampleBuilder.new(time)
-        end
-      end
-
-      # The current thread-local transaction sample builder
-      def tl_builder
-        TransactionState.tl_get.transaction_sample_builder
-      end
     end
   end
 end

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+# This module powers the Busy calculation for the Capacity report in
+# APM (https://rpm.newrelic.com/accounts/.../applications/.../optimize/capacity_analysis).
+#
+#               total time spent in transactions this harvest across all threads
+# Busy time = ------------------------------------------------------------------------
+#             (elapsed time for this harvest cycle) * (# threads that had transactions)
+#
+module NewRelic
+  module Agent
+    module TransactionTimeAggregator
+      TransactionStats = Struct.new :transaction_started_at, :elapsed_transaction_time
+
+      @lock                     = Mutex.new
+      @harvest_cycle_started_at = Time.now
+
+      @stats = Hash.new do |h, k|
+        h[k] = TransactionStats.new nil, 0.0
+      end
+
+      def reset!(timestamp = Time.now)
+        @harvest_cycle_started_at = timestamp
+        @stats.clear
+      end
+
+      def transaction_start(timestamp = Time.now)
+        @lock.synchronize do
+          set_transaction_start_time timestamp
+        end
+      end
+
+      def transaction_stop(timestamp = Time.now, starting_thread_id = current_thread)
+        @lock.synchronize do
+          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!(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(timestamp, thread_id, entry)
+          end
+
+          active_threads = @stats.size
+          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
+          # those in a future harvest)
+          @stats.keep_if do |thread_id, _|
+            in_transaction?(thread_id) && thread_is_alive?(thread_id)
+          end
+
+          if elapsed_harvest_time > 0.0
+            elapsed_transaction_time / elapsed_harvest_time
+          else
+            0.0
+          end
+        end
+
+        if Agent.config[:report_instance_busy]
+          NewRelic::Agent.record_metric(INSTANCE_BUSY_METRIC, result)
+        end
+
+        result
+      end
+
+      module_function :reset!,
+                      :transaction_start,
+                      :transaction_stop,
+                      :harvest!
+
+      class << self
+        private
+
+        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)
+          !!@stats[thread_id].transaction_started_at
+        end
+
+        def current_thread
+          Thread.current.object_id
+        end
+
+        def thread_is_alive?(thread_id)
+          thread = thread_by_id thread_id
+          thread && thread.alive?
+        rescue StandardError
+          false
+        end
+
+        # 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(timestamp, thread_id = nil)
+          raise ArgumentError, 'thread_id required' unless thread_id
+          @stats[thread_id].transaction_started_at = timestamp
+          @stats[thread_id].elapsed_transaction_time = 0.0
+        end
+
+        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 timestamp, thread_id
+
+          # ...then readjust the transaction start time to the next harvest
+          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
+end