newrelic_rpm 4.8.0.341 → 6.13.1

data/lib/new_relic/agent/throughput_monitor.rb

@@ -1,59 +0,0 @@
-# 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.
-
-module NewRelic
-  module Agent
-    class ThroughputMonitor
-
-      def initialize target_samples = 10
-        @target = target_samples
-        @seen = 0
-        @seen_last = 0
-        @sampled_count = 0
-        @first_cycle = true
-        @lock = Mutex.new
-      end
-
-      # Called at the beginning of each transaction, increments seen and
-      # returns a boolean indicating if we should mark the transaction as
-      # sampled. This uses the adaptive sampling algorithm.
-      def sampled?
-        @lock.synchronize do
-          sampled = if @first_cycle
-            @sampled_count < 10
-          elsif @sampled_count < @target
-            rand(@seen_last) < @target
-          else
-            rand(@seen) < (@target ** (@target / @sampled_count) - @target ** 0.51)
-          end
-
-          @sampled_count += 1 if sampled
-          @seen += 1
-
-          sampled
-        end
-      end
-
-      def reset!
-        @lock.synchronize do
-          @first_cycle = false
-          @seen_last = @seen
-          @seen = 0
-          @sampled_count = 0
-        end
-      end
-
-      def stats
-        @lock.synchronize do
-          {
-            target: @target,
-            seen: @seen,
-            seen_last: @seen_last,
-            sampled_count: @sampled_count
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-# 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.
-
-require 'new_relic/agent/attribute_processing'
-
-module NewRelic
-  module Agent
-    class Transaction
-      class Attributes
-        KEY_LIMIT   = 255
-        VALUE_LIMIT = 255
-        COUNT_LIMIT = 64
-
-        EMPTY_HASH = {}.freeze
-
-        def initialize(filter)
-          @filter = filter
-
-          @custom_attributes = {}
-          @agent_attributes = {}
-          @intrinsic_attributes = {}
-
-          @custom_destinations = {}
-          @agent_destinations = {}
-          @already_warned_count_limit = nil
-        end
-
-        def add_agent_attribute(key, value, default_destinations)
-          destinations = @filter.apply(key, default_destinations)
-          return if destinations == AttributeFilter::DST_NONE
-
-          @agent_destinations[key] = destinations
-          add(@agent_attributes, key, value)
-        end
-
-        def add_agent_attribute_with_key_check(key, value, default_destinations)
-          if exceeds_bytesize_limit? key, KEY_LIMIT
-            NewRelic::Agent.logger.debug("Agent attribute #{key} was dropped for exceeding key length limit #{KEY_LIMIT}")
-            return
-          end
-
-          add_agent_attribute(key, value, default_destinations)
-        end
-
-        def add_intrinsic_attribute(key, value)
-          add(@intrinsic_attributes, key, value)
-        end
-
-        def merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
-          return if @filter.high_security?
-          return if !@filter.might_allow_prefix?(prefix)
-
-          AttributeProcessing.flatten_and_coerce(attributes, prefix) do |k, v|
-            add_agent_attribute_with_key_check(k, v, AttributeFilter::DST_NONE)
-          end
-        end
-
-        def merge_custom_attributes(other)
-          return if other.empty?
-          AttributeProcessing.flatten_and_coerce(other) do |k, v|
-            add_custom_attribute(k, v)
-          end
-        end
-
-        def custom_attributes_for(destination)
-          for_destination(@custom_attributes, @custom_destinations, destination)
-        end
-
-        def agent_attributes_for(destination)
-          for_destination(@agent_attributes, @agent_destinations, destination)
-        end
-
-        def intrinsic_attributes_for(destination)
-          if destination == NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER ||
-             destination == NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
-            @intrinsic_attributes
-          else
-            EMPTY_HASH
-          end
-        end
-
-        private
-
-        def add_custom_attribute(key, value)
-          if @custom_attributes.size >= COUNT_LIMIT
-            unless @already_warned_count_limit
-              NewRelic::Agent.logger.warn("Custom attributes count exceeded limit of #{COUNT_LIMIT}. Any additional custom attributes during this transaction will be dropped.")
-              @already_warned_count_limit = true
-            end
-            return
-          end
-
-          if @filter.high_security?
-            NewRelic::Agent.logger.debug("Unable to add custom attribute #{key} while in high security mode.")
-            return
-          end
-
-          if exceeds_bytesize_limit?(key, KEY_LIMIT)
-            NewRelic::Agent.logger.warn("Custom attribute key '#{key}' was longer than limit of #{KEY_LIMIT} bytes. This attribute will be dropped.")
-            return
-          end
-
-          destinations = @filter.apply(key, AttributeFilter::DST_ALL)
-          return if destinations == AttributeFilter::DST_NONE
-
-          @custom_destinations[key] = destinations
-          add(@custom_attributes, key, value)
-        end
-
-        def add(attributes, key, value)
-          return if value.nil?
-
-          if exceeds_bytesize_limit?(value, VALUE_LIMIT)
-            value = slice(value)
-          end
-
-          attributes[key] = value
-        end
-
-        def for_destination(attributes, calculated_destinations, destination)
-          # Avoid allocating anything if there are no attrs at all
-          return EMPTY_HASH if attributes.empty?
-
-          attributes.inject({}) do |memo, (key, value)|
-            if @filter.allows?(calculated_destinations[key], destination)
-              memo[key] = value
-            end
-            memo
-          end
-        end
-
-        def exceeds_bytesize_limit?(value, limit)
-          if value.respond_to?(:bytesize)
-            value.bytesize > limit
-          elsif value.is_a?(Symbol)
-            value.to_s.bytesize > limit
-          else
-            false
-          end
-        end
-
-        # Take one byte past our limit. Why? This lets us unconditionally chop!
-        # the end. It'll either remove the one-character-too-many we have, or
-        # peel off the partial, mangled character left by the byteslice.
-        def slice(incoming)
-          result = incoming.to_s.byteslice(0, VALUE_LIMIT + 1)
-          result.chop!
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# 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.
-
-require 'new_relic/agent/transaction/transaction_sample_buffer'
-
-module NewRelic
-  module Agent
-    class Transaction
-      class XraySampleBuffer < TransactionSampleBuffer
-
-        attr_writer :xray_session_collection
-
-        def initialize
-          super
-
-          # Memoize the config setting since this happens per request
-          @enabled = NewRelic::Agent.config[:'xray_session.allow_traces']
-          NewRelic::Agent.config.register_callback(:'xray_session.allow_traces') do |new_value|
-            @enabled = new_value
-          end
-
-          @capacity = NewRelic::Agent.config[:'xray_session.max_samples']
-          NewRelic::Agent.config.register_callback(:'xray_session.max_samples') do |new_value|
-            @capacity = new_value
-          end
-        end
-
-        def xray_session_collection
-          @xray_session_collection ||= NewRelic::Agent.instance.agent_command_router.xray_session_collection
-        end
-
-        def capacity
-          @capacity
-        end
-
-        def truncate_samples
-          # First in wins, so stop on allow_sample? instead of truncating
-        end
-
-        def allow_sample?(sample)
-          !full? && !lookup_session_id(sample).nil?
-        end
-
-        def enabled?
-          @enabled
-        end
-
-
-        private
-
-        def add_sample(sample)
-          super(sample)
-          sample.xray_session_id = lookup_session_id(sample)
-        end
-
-        def lookup_session_id(sample)
-          xray_session_collection.session_id_for_transaction_name(sample.transaction_name)
-        end
-
-      end
-    end
-  end
-end

data/lib/new_relic/agent/transaction_state.rb

@@ -1,145 +0,0 @@
-# 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.
-
-module NewRelic
-  module Agent
-
-    # This is THE location to store thread local information during a transaction
-    # Need a new piece of data? Add a method here, NOT a new thread local variable.
-    class TransactionState
-      def self.tl_get
-        tl_state_for(Thread.current)
-      end
-
-      # This method should only be used by TransactionState for access to the
-      # current thread's state or to provide read-only accessors for other threads
-      #
-      # If ever exposed, this requires additional synchronization
-      def self.tl_state_for(thread)
-        state = thread[:newrelic_transaction_state]
-
-        if state.nil?
-          state = TransactionState.new
-          thread[:newrelic_transaction_state] = state
-        end
-
-        state
-      end
-
-      def self.tl_clear
-        Thread.current[:newrelic_transaction_state] = nil
-      end
-
-      def initialize
-        @untraced = []
-        @current_transaction = nil
-        @record_tt = nil
-        @record_sql = nil
-      end
-
-      # This starts the timer for the transaction.
-      def reset(transaction=nil)
-        # We purposefully don't reset @untraced, @record_tt and @record_sql
-        # since those are managed by NewRelic::Agent.disable_* calls explicitly
-        # and (more importantly) outside the scope of a transaction
-
-        @timings = nil
-        @request = nil
-        @current_transaction = transaction
-
-
-        @is_cross_app_caller = false
-        @client_cross_app_id = nil
-        @referring_transaction_info = nil
-
-        @sql_sampler_transaction_data = nil
-
-        @busy_entries = 0
-      end
-
-      def timings
-        @timings ||= TransactionTimings.new(transaction_queue_time, transaction_start_time, transaction_name)
-      end
-
-      # Cross app tracing
-      # Because we need values from headers before the transaction actually starts
-      attr_accessor :client_cross_app_id, :referring_transaction_info, :is_cross_app_caller
-
-      def is_cross_app_caller?
-        @is_cross_app_caller
-      end
-
-      def is_cross_app_callee?
-        referring_transaction_info != nil
-      end
-
-      def is_cross_app?
-        is_cross_app_caller? || is_cross_app_callee?
-      end
-
-      # Request data
-      attr_accessor :request
-
-      def request_guid
-        return nil unless current_transaction
-        current_transaction.guid
-      end
-
-      # Current transaction stack
-      attr_reader   :current_transaction
-
-      def transaction_start_time
-        current_transaction.start_time if current_transaction
-      end
-
-      def transaction_queue_time
-        current_transaction.nil? ? 0.0 : current_transaction.queue_time
-      end
-
-      def transaction_name
-        current_transaction.nil? ? nil : current_transaction.best_name
-      end
-
-      def in_background_transaction?
-        !current_transaction.nil? && !current_transaction.recording_web_transaction?
-      end
-
-      def in_web_transaction?
-        !current_transaction.nil? && current_transaction.recording_web_transaction?
-      end
-
-      # Execution tracing on current thread
-      attr_accessor :untraced
-
-      def push_traced(should_trace)
-        @untraced << should_trace
-      end
-
-      def pop_traced
-        @untraced.pop if @untraced
-      end
-
-      def is_execution_traced?
-        @untraced.nil? || @untraced.last != false
-      end
-
-      # TT's and SQL
-      attr_accessor :record_tt, :record_sql
-
-      def is_transaction_traced?
-        @record_tt != false
-      end
-
-      def is_sql_recorded?
-        @record_sql != false
-      end
-
-      # Busy calculator
-      attr_accessor :busy_entries
-
-      # Sql Sampler Transaction Data
-      attr_accessor :sql_sampler_transaction_data
-    end
-  end
-end

data/lib/new_relic/agent/transaction_timings.rb

@@ -1,57 +0,0 @@
-# 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.
-
-module NewRelic
-  module Agent
-    class TransactionTimings
-
-      def initialize(queue_time_in_seconds, start_time_in_seconds, transaction_name)
-        @now = Time.now.to_f
-        @queue_time_in_seconds = clamp_to_positive(queue_time_in_seconds.to_f)
-        @start_time_in_seconds = clamp_to_positive(start_time_in_seconds.to_f)
-
-        @transaction_name = transaction_name
-      end
-
-      attr_reader :transaction_name,
-                  :start_time_in_seconds, :queue_time_in_seconds
-
-      def transaction_name_or_unknown
-        transaction_name || ::NewRelic::Agent::UNKNOWN_METRIC
-      end
-
-      def start_time_as_time
-        Time.at(@start_time_in_seconds)
-      end
-
-      def start_time_in_millis
-        convert_to_milliseconds(@start_time_in_seconds)
-      end
-
-      def queue_time_in_millis
-        convert_to_milliseconds(queue_time_in_seconds)
-      end
-
-      def app_time_in_millis
-        convert_to_milliseconds(app_time_in_seconds)
-      end
-
-      def app_time_in_seconds
-        @now - @start_time_in_seconds
-      end
-
-      # Helpers
-
-      def convert_to_milliseconds(value_in_seconds)
-        clamp_to_positive((value_in_seconds.to_f * 1000.0).round)
-      end
-
-      def clamp_to_positive(value)
-        return 0.0 if value < 0.0
-        value
-      end
-
-    end
-  end
-end