newrelic_rpm 3.12.0.288 → 9.10.2

data/lib/new_relic/agent/transaction_sampler.rb

@@ -1,18 +1,13 @@
-# 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.
+# frozen_string_literal: true
 
-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/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
-
     # This class contains the logic for recording and storing transaction
     # traces (sometimes referred to as 'transaction samples').
     #
@@ -22,24 +17,10 @@ module NewRelic
     #
     # @api public
     class TransactionSampler
-
-      # Module defining methods stubbed out when the agent is disabled
-      module Shim #:nodoc:
-        def on_start_transaction(*args); end
-        def notice_push_frame(*args); end
-        def notice_pop_frame(*args); end
-        def on_finishing_transaction(*args); end
-      end
-
-      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
 
@@ -51,79 +32,29 @@ module NewRelic
         Agent.config.register_callback(:'transaction_tracer.enabled') do |enabled|
           if enabled
             threshold = Agent.config[:'transaction_tracer.transaction_threshold']
-            ::NewRelic::Agent.logger.debug "Transaction tracing threshold is #{threshold} seconds."
+            ::NewRelic::Agent.logger.debug("Transaction tracing threshold is #{threshold} seconds.")
           else
-            ::NewRelic::Agent.logger.debug "Transaction traces will not be sent to the New Relic service."
+            ::NewRelic::Agent.logger.debug('Transaction traces will not be sent to the New Relic service.')
           end
         end
 
         Agent.config.register_callback(:'transaction_tracer.record_sql') do |config|
           if config == 'raw'
-            ::NewRelic::Agent.logger.warn("Agent is configured to send raw SQL to the service")
+            ::NewRelic::Agent.logger.warn('Agent is configured to send raw SQL to the service')
           end
         end
       end
 
       def enabled?
-        Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
+        Agent.config[:'transaction_tracer.enabled']
       end
 
-      def on_start_transaction(state, start_time)
-        if enabled?
-          start_builder(state, start_time.to_f)
-          builder = state.transaction_sample_builder
-        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)
-      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
@@ -134,125 +65,9 @@ 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
-            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
-              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) #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 = build_database_statement(sql, config, explainer)
-          notice_extra_data(builder, statement, duration, :sql)
-        end
-      end
-
-      def build_database_statement(sql, config, explainer)
-        statement = Database::Statement.new(Database.capture_query(sql))
-        if config
-          statement.adapter = config[:adapter]
-          statement.config = config
-        end
-        statement.explainer = explainer
-
-        statement
-      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?
+        return NewRelic::EMPTY_ARRAY unless enabled?
 
         samples = @samples_lock.synchronize do
           @last_sample = nil
@@ -266,7 +81,7 @@ module NewRelic
           begin
             sample.prepare_to_send!
           rescue => e
-            NewRelic::Agent.logger.error("Failed to prepare transaction trace. Error: ", e)
+            NewRelic::Agent.logger.error('Failed to prepare transaction trace. Error: ', e)
             false
           else
             true
@@ -295,7 +110,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)
@@ -305,25 +127,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,160 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+# 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 = Process.clock_gettime(Process::CLOCK_REALTIME)
+
+      @stats = Hash.new do |h, k|
+        h[k] = TransactionStats.new(nil, 0.0)
+      end
+
+      def reset!(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
+        @harvest_cycle_started_at = timestamp
+        @stats.clear
+      end
+
+      def transaction_start(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
+        @lock.synchronize do
+          set_transaction_start_time(timestamp)
+        end
+      end
+
+      def transaction_stop(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME), 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 = Process.clock_gettime(Process::CLOCK_REALTIME))
+        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)
+          # needs else branch coverage
+          thread && thread.alive? # rubocop:disable Style/SafeNavigation
+        rescue StandardError
+          false
+        end
+
+        # ObjectSpace is faster on MRI, but disabled by default on JRuby for
+        # performance reasons. We have two implementations 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
+
+        # this method has no test coverage
+        def log_missing_elapsed_transaction_time
+          # rubocop:disable Style/SafeNavigation
+          transaction_name = transaction_name = Tracer.current_transaction &&
+            Tracer.current_transaction.best_name ||
+            'unknown'
+          # rubocop:enable Style/SafeNavigation
+          NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/aws.rb

@@ -0,0 +1,48 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class AWS < Vendor
+        IMDS_BASE_URL = 'http://169.254.169.254/latest'.freeze
+        IMDS_KEYS = %w[instanceId instanceType availabilityZone].freeze
+        IMDS_TOKEN_TTL_SECS = '60'.freeze
+        TOKEN_OPEN_TIMEOUT_SECS = 1.freeze
+        TOKEN_READ_TIMEOUT_SECS = 1.freeze
+
+        class << self
+          def imds_token
+            uri = URI.parse("#{IMDS_BASE_URL}/api/token")
+            http = Net::HTTP.new(uri.hostname)
+            http.open_timeout = TOKEN_OPEN_TIMEOUT_SECS
+            http.read_timeout = TOKEN_READ_TIMEOUT_SECS
+            response = http.send_request('PUT',
+              uri.path,
+              '',
+              {'X-aws-ec2-metadata-token-ttl-seconds' => IMDS_TOKEN_TTL_SECS})
+            unless response.code == Vendor::SUCCESS
+              NewRelic::Agent.logger.debug('Failed to obtain an AWS token for use with IMDS - encountered ' \
+                                           "#{response.class} with HTTP response code #{response.code} - " \
+                                           'assuming non AWS')
+              return
+            end
+
+            response.body
+          rescue Net::OpenTimeout
+            NewRelic::Agent.logger.debug('Timed out waiting for AWS IMDS - assuming non AWS')
+          end
+        end
+
+        vendor_name 'aws'
+        endpoint "#{IMDS_BASE_URL}/dynamic/instance-identity/document"
+        keys IMDS_KEYS
+        headers 'X-aws-ec2-metadata-token' => -> { imds_token }
+        key_transforms :to_sym
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/azure.rb

@@ -0,0 +1,17 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module Utilization
+      class Azure < Vendor
+        vendor_name 'azure'
+        endpoint 'http://169.254.169.254/metadata/instance/compute?api-version=2017-03-01'
+        headers 'Metadata' => 'true'
+        keys %w[vmId name vmSize location]
+        key_transforms :to_sym
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/gcp.rb

@@ -0,0 +1,33 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class GCP < Vendor
+        vendor_name 'gcp'
+        endpoint 'http://metadata.google.internal/computeMetadata/v1/instance/?recursive=true'
+        headers 'Metadata-Flavor' => 'Google'
+        keys %w[id machineType name zone]
+        key_transforms :to_sym
+
+        MACH_TYPE = 'machineType'.freeze
+        ZONE = 'zone'.freeze
+
+        def prepare_response(response)
+          body = JSON.parse(response.body)
+          body[MACH_TYPE] = trim_leading(body[MACH_TYPE])
+          body[ZONE] = trim_leading(body[ZONE])
+          body
+        end
+
+        def trim_leading(value)
+          value.split(NewRelic::SLASH).last
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/pcf.rb

@@ -0,0 +1,33 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class PCF < Vendor
+        vendor_name 'pcf'
+        keys %w[CF_INSTANCE_GUID CF_INSTANCE_IP MEMORY_LIMIT]
+        key_transforms [:downcase, :to_sym]
+
+        def detect
+          begin
+            return false unless pcf_keys_present?
+
+            process_response(ENV)
+          rescue
+            NewRelic::Agent.logger.error("Error occurred detecting: #{vendor_name}", e)
+            record_supportability_metric
+            false
+          end
+        end
+
+        def pcf_keys_present?
+          !(ENV.keys & keys).empty?
+        end
+      end
+    end
+  end
+end