newrelic_rpm 5.5.0.348 → 7.2.0

data/lib/new_relic/agent/instrumentation/active_record_5.rb

@@ -1,41 +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/instrumentation/active_record_subscriber'
-require 'new_relic/agent/instrumentation/active_record_prepend'
-
-DependencyDetection.defer do
-  named :active_record_5
-
-  depends_on do
-    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
-      defined?(::ActiveRecord::VERSION) &&
-      ::ActiveRecord::VERSION::MAJOR.to_i == 5
-  end
-
-  depends_on do
-    !NewRelic::Agent.config[:disable_activerecord_instrumentation] &&
-      !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveRecord 5 instrumentation'
-  end
-
-  executes do
-    ActiveSupport::Notifications.subscribe('sql.active_record',
-      NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new)
-
-    ActiveSupport.on_load(:active_record) do
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActiveRecord::Base, ::ActiveRecord::Relation)
-      ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions
-      ::ActiveRecord::Relation.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions
-
-      if ::ActiveRecord::VERSION::MINOR.to_i == 1 &&
-         ::ActiveRecord::VERSION::TINY.to_i >= 6
-        ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516
-      end
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/evented_subscriber.rb

@@ -1,104 +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
-    module Instrumentation
-      class EventedSubscriber
-        def initialize
-          @queue_key = ['NewRelic', self.class.name, object_id].join('-')
-        end
-
-        def self.subscribed?
-          # TODO: need to talk to Rails core about an API for this,
-          # rather than digging through Listener ivars
-          ActiveSupport::Notifications.notifier.instance_variable_get(:@subscribers) \
-            .find{|s| s.instance_variable_get(:@delegate).class == self }
-        end
-
-        def self.subscribe(pattern)
-          if !subscribed?
-            ActiveSupport::Notifications.subscribe(pattern, new)
-          end
-        end
-
-        def start(name, id, payload)
-          event = ActiveSupport::Notifications::Event.new(name, Time.now, nil, id, payload)
-          push_event(event)
-          return event
-        end
-
-        def finish(name, id, payload)
-          pop_event(id)
-        end
-
-        def log_notification_error(error, name, event_type)
-          # These are important enough failures that we want the backtraces
-          # logged at error level, hence the explicit log_exception call.
-          NewRelic::Agent.logger.error("Error during #{event_type} callback for event '#{name}':")
-          NewRelic::Agent.logger.log_exception(:error, error)
-        end
-
-        def push_event(event)
-          parent = event_stack[event.transaction_id].last
-          if parent && event.respond_to?(:parent=)
-            event.parent = parent
-            parent << event
-          end
-          event_stack[event.transaction_id].push event
-        end
-
-        def pop_event(transaction_id)
-          event = event_stack[transaction_id].pop
-          event.end = Time.now
-          return event
-        end
-
-        def event_stack
-          Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
-        end
-
-        def state
-          NewRelic::Agent::TransactionState.tl_get
-        end
-      end
-
-      # Taken from ActiveSupport::Notifications::Event, pasted here
-      # with a couple minor additions so we don't have a hard
-      # dependency on ActiveSupport::Notifications.
-      #
-      # Represents an instrumentation event, provides timing and metric
-      # name information useful when recording metrics.
-      class Event
-        attr_reader :name, :time, :transaction_id, :payload, :children
-        attr_accessor :end, :parent, :frame
-
-        def initialize(name, start, ending, transaction_id, payload)
-          @name           = name
-          @payload        = payload.dup
-          @time           = start
-          @transaction_id = transaction_id
-          @end            = ending
-          @children       = []
-        end
-
-        def metric_name
-          raise NotImplementedError
-        end
-
-        def duration
-          self.end - time
-        end
-
-        def <<(event)
-          @children << event
-        end
-
-        def parent_of?(event)
-          @children.include? event
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/http.rb

@@ -1,46 +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.
-
-DependencyDetection.defer do
-  named :httprb
-
-  depends_on do
-    defined?(HTTP) && defined?(HTTP::Client)
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing http.rb instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
-    require 'new_relic/agent/http_clients/http_rb_wrappers'
-  end
-
-  executes do
-    class HTTP::Client
-      def perform_with_newrelic_trace(request, options)
-        wrapped_request = ::NewRelic::Agent::HTTPClients::HTTPRequest.new(request)
-
-        begin
-          segment = NewRelic::Agent::Tracer.start_external_request_segment(
-            library: wrapped_request.type,
-            uri: wrapped_request.uri,
-            procedure: wrapped_request.method
-          )
-
-          segment.add_request_headers wrapped_request
-
-          response = perform_without_newrelic_trace(request, options)
-          wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPResponse.new response
-          segment.read_response_headers wrapped_response
-
-          response
-        ensure
-          segment.finish if segment
-        end
-      end
-
-      alias perform_without_newrelic_trace perform
-      alias perform perform_with_newrelic_trace
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/net.rb

@@ -1,50 +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.
-
-DependencyDetection.defer do
-  named :net_http
-
-  depends_on do
-    defined?(Net) && defined?(Net::HTTP)
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Net instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
-    require 'new_relic/agent/http_clients/net_http_wrappers'
-  end
-
-  executes do
-    class Net::HTTP
-      def request_with_newrelic_trace(request, *args, &block)
-        wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
-
-        segment = NewRelic::Agent::Transaction.start_external_request_segment(
-          library: wrapped_request.type,
-          uri: wrapped_request.uri,
-          procedure: wrapped_request.method
-        )
-
-        begin
-          response = nil
-          segment.add_request_headers wrapped_request
-
-          # RUBY-1244 Disable further tracing in request to avoid double
-          # counting if connection wasn't started (which calls request again).
-          NewRelic::Agent.disable_all_tracing do
-            response = request_without_newrelic_trace( request, *args, &block )
-          end
-
-          segment.read_response_headers response
-          response
-        ensure
-          segment.finish
-        end
-      end
-
-      alias request_without_newrelic_trace request
-      alias request request_with_newrelic_trace
-    end
-  end
-end

data/lib/new_relic/agent/instrumentation/rails4/action_controller.rb

@@ -1,32 +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/instrumentation/action_controller_subscriber'
-require 'new_relic/agent/prepend_supportability'
-
-
-DependencyDetection.defer do
-  @name = :rails4_controller
-
-  depends_on do
-    defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i == 4
-  end
-
-  depends_on do
-    defined?(ActionController) && defined?(ActionController::Base)
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 4 Controller instrumentation'
-  end
-
-  executes do
-    class ActionController::Base
-      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-    end
-    NewRelic::Agent::Instrumentation::ActionControllerSubscriber \
-      .subscribe(/^process_action.action_controller$/)
-
-    ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionController::Base)
-  end
-end

data/lib/new_relic/agent/instrumentation/rails5/action_view.rb

@@ -1,27 +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/instrumentation/action_view_subscriber'
-require 'new_relic/agent/prepend_supportability'
-
-DependencyDetection.defer do
-  @name = :rails5_view
-
-  depends_on do
-    defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i == 5
-  end
-
-  depends_on do
-    !NewRelic::Agent.config[:disable_view_instrumentation] &&
-      !NewRelic::Agent::Instrumentation::ActionViewSubscriber.subscribed?
-  end
-
-  executes do
-    NewRelic::Agent.logger.info 'Installing Rails 5 view instrumentation'
-  end
-
-  executes do
-    NewRelic::Agent::Instrumentation::ActionViewSubscriber.subscribe(/render_.+\.action_view$/)
-    NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionView::Base, ::ActionView::Template, ::ActionView::Renderer)
-  end
-end

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

@@ -1,154 +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 unless Agent.config[:'custom_attributes.enabled']
-          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