newrelic_rpm 6.3.0.355 → 6.8.0.360

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

@@ -13,11 +13,13 @@ module NewRelic
   module Agent
     module Instrumentation
       module ActiveRecordNotifications
-        module BaseExtensions41
+        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_ACTIVE_RECORD,
               :sql            => sql,
               :name           => name,
               :connection_id  => object_id,
@@ -25,7 +27,12 @@ module NewRelic
               :statement_name => statement_name,
               :binds          => binds) { yield }
           rescue => e
-            raise translate_exception(e, sql)
+            # 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
 
@@ -33,7 +40,7 @@ module NewRelic
           # 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_ACTIVE_RECORD,
               sql:               sql,
               name:              name,
               binds:             binds,
@@ -50,7 +57,7 @@ module NewRelic
           # 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_ACTIVE_RECORD,
               sql:               sql,
               name:              name,
               binds:             binds,
@@ -87,17 +94,17 @@ DependencyDetection.defer do
 
 
   depends_on do
-    # If the deprecated :disable_active_record_4 setting is true, and 
+    # 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 
+    # 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 
+        || ::ActiveRecord::VERSION::MAJOR.to_i  != 5
   end
 
 
@@ -116,7 +123,7 @@ DependencyDetection.defer do
           ::ActiveRecord::Base,
           ::ActiveRecord::Relation)
 
-      # Default to .prepending, unless the ActiveRecord version is <=4 
+      # 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]
@@ -133,15 +140,15 @@ DependencyDetection.defer do
 
   executes do
     if NewRelic::Agent.config[:backport_fast_active_record_connection_lookup]
-
-      activerecord_extension = if ::ActiveRecord::VERSION::MAJOR.to_i == 4
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions41
-      elsif ::ActiveRecord::VERSION::MAJOR.to_i == 5
-        if ::ActiveRecord::VERSION::MINOR.to_i == 0
-          ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
-        elsif ::ActiveRecord::VERSION::MINOR.to_i >= 1
-          ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
-        end
+      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?

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,6 +31,7 @@ module NewRelic
           # we don't expect this to be called more than once, but we're being
           # defensive.
           return if defined?(cached?)
+
           if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::STRING >= "5.1.0"
             def cached?(payload)
               payload.fetch(:cached, false)
@@ -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
@@ -99,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
+          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 state
-            @state ||= NewRelic::Agent::Tracer.state
-          end
-
-          def sql
-            @sql ||= Helper.correctly_encoded payload[:sql]
-          end
+          segment._notice_sql sql, config, @explainer, payload[:binds], payload[:name]
+          segment
         end
       end
     end

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

@@ -1,12 +1,12 @@
 # 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'
 
 module NewRelic
   module Agent
     module Instrumentation
-      class ActiveStorageSubscriber < EventedSubscriber
+      class ActiveStorageSubscriber < NotificationsSubscriber
         def start name, id, payload
           return unless state.is_execution_traced?
           start_segment name, id, payload
@@ -25,11 +25,11 @@ module NewRelic
           segment = Tracer.start_segment name: metric_name(name, payload)
           segment.params[:key] = payload[:key]
           segment.params[:exist] = payload[:exist] if payload.key? :exist
-          event_stack[id].push segment
+          push_segment id, segment
         end
 
         def finish_segment id
-          segment = event_stack[id].pop
+          segment = pop_segment id
           segment.finish if segment
         end
 

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

@@ -133,9 +133,8 @@ DependencyDetection.defer do
             endpoint = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_ENDPOINT]
             version = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_VERSION]
 
-            # Since 1.2.0, how to obtain the class name is changed.
-            class_name = self.class.respond_to?(:base) ? self.class.base.name : self.class.name
-            ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, class_name, version)
+            api_class = (self.class.respond_to?(:base) && self.class.base) || self.class
+            ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, api_class.name, version)
           rescue => e
             ::NewRelic::Agent.logger.warn("Error in Grape instrumentation", e)
           end

data/lib/new_relic/agent/instrumentation/{evented_subscriber.rb → notifications_subscriber.rb}

@@ -5,7 +5,7 @@
 module NewRelic
   module Agent
     module Instrumentation
-      class EventedSubscriber
+      class NotificationsSubscriber
         def initialize
           @queue_key = ['NewRelic', self.class.name, object_id].join('-')
         end
@@ -46,16 +46,6 @@ module NewRelic
           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.
@@ -63,30 +53,16 @@ module NewRelic
           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
+        def push_segment(id, segment)
+          segment_stack[id].push segment
         end
 
-        def pop_event(transaction_id)
-          event = event_stack[transaction_id].pop
-
-          if event.respond_to?(:finish!)
-            # ActiveSupport version 6 and greater use a finish! method rather
-            # that allowing us to set the end directly
-            event.finish!
-          else
-            event.end = Time.now
-          end
-
-          return event
+        def pop_segment(id)
+          segment = segment_stack[id].pop
+          segment
         end
 
-        def event_stack
+        def segment_stack
           Thread.current[@queue_key] ||= Hash.new {|h,id| h[id] = [] }
         end
 
@@ -95,41 +71,6 @@ module NewRelic
         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