newrelic_rpm 6.1.0.352 → 6.6.0.358

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

@@ -1,87 +1,104 @@
 # 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/evented_subscriber'
+require 'new_relic/agent/instrumentation/notifications_subscriber'
 
 # Listen for ActiveSupport::Notifications events for ActionView render
 # events.  Write metric data and transaction trace nodes for each event.
 module NewRelic
   module Agent
     module Instrumentation
-      class ActionViewSubscriber < EventedSubscriber
+      class ActionViewSubscriber < NotificationsSubscriber
 
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = RenderEvent.new(name, Time.now, nil, id, payload)
-          push_event(event)
-          if state.is_execution_traced? && event.recordable?
-            event.segment = NewRelic::Agent::Tracer.start_segment name: event.metric_name
+          parent = segment_stack[id].last
+          metric_name = format_metric_name(name, payload, parent)
+
+          event = ActionViewEvent.new(metric_name, payload[:identifier])
+          if state.is_execution_traced? && recordable?(name, metric_name)
+            event.finishable = Tracer.start_segment(name: metric_name)
           end
+          push_segment id, event
         rescue => e
           log_notification_error(e, name, 'start')
         end
 
         def finish(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = pop_event(id)
-          event.segment.finish if event.segment
+          event = pop_segment(id)
+          event.finish if event
         rescue => e
           log_notification_error(e, name, 'finish')
         end
 
-        class RenderEvent < Event
-          attr_accessor :segment
-
-          RENDER_TEMPLATE_EVENT_NAME   = 'render_template.action_view'.freeze
-          RENDER_PARTIAL_EVENT_NAME    = 'render_partial.action_view'.freeze
-          RENDER_COLLECTION_EVENT_NAME = 'render_collection.action_view'.freeze
+        def format_metric_name(event_name, payload, parent)
+          return parent.name if parent \
+             && (payload[:virtual_path] \
+              || (parent.identifier =~ /template$/))
 
-          # Nearly every "render_blah.action_view" event has a child
-          # in the form of "!render_blah.action_view".  The children
-          # are the ones we want to record.  There are a couple
-          # special cases of events without children.
-          def recordable?
-            name[0] == '!' ||
-              metric_name == 'View/text template/Rendering' ||
-              metric_name == "View/#{::NewRelic::Agent::UNKNOWN_METRIC}/Partial"
+          if payload.key?(:virtual_path)
+            identifier = payload[:virtual_path]
+          else
+            identifier = payload[:identifier]
           end
 
-          def metric_name
-            if parent && (payload[:virtual_path] ||
-                          (parent.payload[:identifier] =~ /template$/))
-              return parent.metric_name
-            elsif payload.key?(:virtual_path)
-              identifier = payload[:virtual_path]
-            else
-              identifier = payload[:identifier]
-            end
+          "View/#{metric_path(event_name, identifier)}/#{metric_action(event_name)}"
+        end
 
-            # memoize
-            @metric_name ||= "View/#{metric_path(name, identifier)}/#{metric_action(name)}"
-            @metric_name
-          end
+        # Nearly every "render_blah.action_view" event has a child
+        # in the form of "!render_blah.action_view".  The children
+        # are the ones we want to record.  There are a couple
+        # special cases of events without children.
+        def recordable?(event_name, metric_name)
+          event_name[0] == '!' \
+              || metric_name == 'View/text template/Rendering' \
+              || metric_name == "View/#{::NewRelic::Agent::UNKNOWN_METRIC}/Partial"
+        end
+
+        RENDER_TEMPLATE_EVENT_NAME   = 'render_template.action_view'.freeze
+        RENDER_PARTIAL_EVENT_NAME    = 'render_partial.action_view'.freeze
+        RENDER_COLLECTION_EVENT_NAME = 'render_collection.action_view'.freeze
 
-          def metric_path(name, identifier)
-            # Rails 5 sets identifier to nil for empty collections,
-            # so do not mistake rendering a collection for rendering a file.
-            if identifier == nil && name != RENDER_COLLECTION_EVENT_NAME
-              'file'
-            elsif identifier =~ /template$/
-              identifier
-            elsif identifier && (parts = identifier.split('/')).size > 1
-              parts[-2..-1].join('/')
-            else
-              ::NewRelic::Agent::UNKNOWN_METRIC
-            end
+        def metric_action(name)
+          case name
+          when /#{RENDER_TEMPLATE_EVENT_NAME}$/ then 'Rendering'
+          when RENDER_PARTIAL_EVENT_NAME        then 'Partial'
+          when RENDER_COLLECTION_EVENT_NAME     then 'Partial'
           end
+        end
 
-          def metric_action(name)
-            case name
-            when /#{RENDER_TEMPLATE_EVENT_NAME}$/ then 'Rendering'
-            when RENDER_PARTIAL_EVENT_NAME        then 'Partial'
-            when RENDER_COLLECTION_EVENT_NAME     then 'Partial'
-            end
+        def metric_path(name, identifier)
+          # Rails 5 sets identifier to nil for empty collections,
+          # so do not mistake rendering a collection for rendering a file.
+          if identifier.nil? && name != RENDER_COLLECTION_EVENT_NAME
+            'file'
+          elsif identifier =~ /template$/
+            identifier
+          elsif identifier && (parts = identifier.split('/')).size > 1
+            parts[-2..-1].join('/')
+          else
+            ::NewRelic::Agent::UNKNOWN_METRIC
           end
         end
       end
+
+      # This class holds state information between calls to `start`
+      # and `finish` for ActiveSupport events that we do not want to track
+      # as a transaction or segment.
+      class ActionViewEvent
+        attr_reader :name, :identifier
+        attr_accessor :finishable
+
+        def initialize(name, identifier)
+          @name = name
+          @identifier = identifier
+          @finishable = nil
+        end
+
+        def finish
+          @finishable.finish if @finishable
+        end
+      end
     end
+
   end
 end

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

@@ -0,0 +1,168 @@
+# 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'
+
+
+# Provides a way to send :connection through ActiveSupport notifications to avoid
+# looping through connection handlers to locate a connection by connection_id
+# This is not needed in Rails 6+: https://github.com/rails/rails/pull/34602
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecordNotifications
+        SQL_ACTIVE_RECORD = 'sql.active_record'.freeze
+
+        module BaseExtensions4x
+          # https://github.com/rails/rails/blob/4-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L371
+          def log(sql, name = "SQL", binds = [], statement_name = nil)
+            @instrumenter.instrument(
+              SQL_ACTIVE_RECORD,
+              :sql            => sql,
+              :name           => name,
+              :connection_id  => object_id,
+              :connection     => self,
+              :statement_name => statement_name,
+              :binds          => binds) { yield }
+          rescue => e
+            # The translate_exception_class method got introduced in 4.1
+            if ::ActiveRecord::VERSION::MINOR == 0
+              raise translate_exception(e, sql)
+            else
+              raise translate_exception_class(e, sql)
+            end
+          end
+        end
+
+        module BaseExtensions50
+          # https://github.com/rails/rails/blob/5-0-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L582
+          def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+            @instrumenter.instrument(
+              SQL_ACTIVE_RECORD,
+              sql:               sql,
+              name:              name,
+              binds:             binds,
+              type_casted_binds: type_casted_binds,
+              statement_name:    statement_name,
+              connection_id:     object_id,
+              connection:        self) { yield }
+          rescue => e
+            raise translate_exception_class(e, sql)
+          end
+        end
+
+        module BaseExtensions51
+          # https://github.com/rails/rails/blob/5-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L603
+          def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
+            @instrumenter.instrument(
+              SQL_ACTIVE_RECORD,
+              sql:               sql,
+              name:              name,
+              binds:             binds,
+              type_casted_binds: type_casted_binds,
+              statement_name:    statement_name,
+              connection_id:     object_id,
+              connection:        self) do
+                @lock.synchronize do
+                  yield
+                end
+              end
+          rescue => e
+            raise translate_exception_class(e, sql)
+          end
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  named :active_record_notifications
+
+  depends_on do
+    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
+      defined?(::ActiveRecord::VERSION) &&
+      ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+  end
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_activerecord_instrumentation] &&
+      !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
+  end
+
+
+  depends_on do
+    # If the deprecated :disable_active_record_4 setting is true, and
+    # the active record version is four, disable!
+    NewRelic::Agent.config[:disable_active_record_4] == false \
+        || ::ActiveRecord::VERSION::MAJOR.to_i != 4
+  end
+
+  depends_on do
+    # If the deprecated :disable_active_record_5 setting is true, and
+    # the active record version is five, disable!
+    NewRelic::Agent.config[:disable_active_record_5] == false \
+        || ::ActiveRecord::VERSION::MAJOR.to_i  != 5
+  end
+
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing notifications based Active Record instrumentation'
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe('sql.active_record',
+      NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new)
+  end
+
+  executes do
+    ActiveSupport.on_load(:active_record) do
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(
+          ::ActiveRecord::Base,
+          ::ActiveRecord::Relation)
+
+      # Default to .prepending, unless the ActiveRecord version is <=4
+      # **AND** the :prepend_active_record_instrumentation config is false
+      if ::ActiveRecord::VERSION::MAJOR > 4 \
+          || ::NewRelic::Agent.config[:prepend_active_record_instrumentation]
+
+        ::ActiveRecord::Base.send(:prepend,
+            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
+        ::ActiveRecord::Relation.send(:prepend,
+            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
+      else
+        ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
+      end
+    end
+  end
+
+  executes do
+    if NewRelic::Agent.config[:backport_fast_active_record_connection_lookup]
+      major_version = ::ActiveRecord::VERSION::MAJOR.to_i
+      minor_version = ::ActiveRecord::VERSION::MINOR.to_i
+
+      activerecord_extension = if major_version == 4
+        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
+      elsif major_version == 5 && minor_version == 0
+        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
+      elsif major_version == 5 && minor_version == 1
+        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
+      end
+
+      unless activerecord_extension.nil?
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
+      end
+    end
+  end
+
+  executes do
+    if ::ActiveRecord::VERSION::MAJOR == 5 \
+        && ::ActiveRecord::VERSION::MINOR.to_i == 1 \
+        && ::ActiveRecord::VERSION::TINY.to_i >= 6
+
+      ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516
+    end
+  end
+end

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

@@ -2,7 +2,7 @@
 # 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_helper'
-require 'new_relic/agent/instrumentation/evented_subscriber'
+require 'new_relic/agent/instrumentation/notifications_subscriber'
 
 # Listen for ActiveSupport::Notifications events for ActiveRecord query
 # events.  Write metric data, transaction trace nodes and slow sql
@@ -10,7 +10,7 @@ require 'new_relic/agent/instrumentation/evented_subscriber'
 module NewRelic
   module Agent
     module Instrumentation
-      class ActiveRecordSubscriber < EventedSubscriber
+      class ActiveRecordSubscriber < NotificationsSubscriber
         CACHED_QUERY_NAME = 'CACHE'.freeze
 
         def initialize
@@ -31,7 +31,8 @@ module NewRelic
           # we don't expect this to be called more than once, but we're being
           # defensive.
           return if defined?(cached?)
-          if ::ActiveRecord::VERSION::STRING >= "5.1.0"
+
+          if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::STRING >= "5.1.0"
             def cached?(payload)
               payload.fetch(:cached, false)
             end
@@ -45,9 +46,10 @@ module NewRelic
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
           return if cached?(payload)
           return unless NewRelic::Agent.tl_is_execution_traced?
+
           config = active_record_config(payload)
-          event = ActiveRecordEvent.new(name, Time.now, nil, id, payload, @explainer, config)
-          push_event(event)
+          segment = start_segment(config, payload)
+          push_segment(id, segment)
         rescue => e
           log_notification_error(e, name, 'start')
         end
@@ -55,8 +57,9 @@ module NewRelic
         def finish(name, id, payload) #THREAD_LOCAL_ACCESS
           return if cached?(payload)
           return unless state.is_execution_traced?
-          event = pop_event(id)
-          event.finish
+
+          segment = pop_segment(id)
+          segment.finish if segment
         rescue => e
           log_notification_error(e, name, 'finish')
         end
@@ -78,6 +81,13 @@ module NewRelic
         def active_record_config(payload)
           return unless payload[:connection_id]
 
+          # handle if the notification payload provides the AR connection
+          # available in Rails 6+ & our ActiveRecordNotifications#log extension
+          if payload[:connection]
+            connection_config = payload[:connection].instance_variable_get(:@config)
+            return connection_config if connection_config
+          end
+
           connection = nil
           connection_id = payload[:connection_id]
 
@@ -92,50 +102,33 @@ module NewRelic
           connection.instance_variable_get(:@config) if connection
         end
 
-        class ActiveRecordEvent < Event
-          def initialize(name, start, ending, transaction_id, payload, explainer, config)
-            super(name, start, ending, transaction_id, payload)
-            @explainer = explainer
-            @config = config
-            @segment = start_segment
-          end
-
-          def start_segment
-            product, operation, collection = ActiveRecordHelper.product_operation_collection_for(payload[:name],
-                                              sql, @config && @config[:adapter])
-
-            host = nil
-            port_path_or_id = nil
-            database = nil
-
-            if ActiveRecordHelper::InstanceIdentification.supported_adapter?(@config)
-              host = ActiveRecordHelper::InstanceIdentification.host(@config)
-              port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(@config)
-              database = @config && @config[:database]
-            end
-
-            segment = Tracer.start_datastore_segment product: product,
-                                                          operation: operation,
-                                                          collection: collection,
-                                                          host: host,
-                                                          port_path_or_id: port_path_or_id,
-                                                          database_name: database
-
-            segment._notice_sql sql, @config, @explainer, payload[:binds], payload[:name]
-            segment
+        def start_segment(config, payload)
+          sql = Helper.correctly_encoded payload[:sql]
+          product, operation, collection = ActiveRecordHelper.product_operation_collection_for(
+            payload[:name],
+            sql,
+            config && config[:adapter]
+          )
+
+          host = nil
+          port_path_or_id = nil
+          database = nil
+
+          if ActiveRecordHelper::InstanceIdentification.supported_adapter?(config)
+            host = ActiveRecordHelper::InstanceIdentification.host(config)
+            port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(config)
+            database = config && config[:database]
           end
 
-          def finish
-            @segment.finish if @segment
-          end
-
-          def state
-            @state ||= NewRelic::Agent::Tracer.state
-          end
+          segment = Tracer.start_datastore_segment(product: product,
+            operation: operation,
+            collection: collection,
+            host: host,
+            port_path_or_id: port_path_or_id,
+            database_name: database)
 
-          def sql
-            @sql ||= Helper.correctly_encoded payload[:sql]
-          end
+          segment._notice_sql sql, config, @explainer, payload[:binds], payload[:name]
+          segment
         end
       end
     end