newrelic_rpm 4.0.0.332 → 6.13.1

data/lib/new_relic/agent/instrumentation.rb

@@ -1,6 +1,6 @@
 # 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.
 
 require 'new_relic/agent'
 module NewRelic

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

@@ -1,75 +1,58 @@
 # 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'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+require 'new_relic/agent/instrumentation/notifications_subscriber'
 
 module NewRelic
   module Agent
     module Instrumentation
-      class ActionCableSubscriber < EventedSubscriber
+      class ActionCableSubscriber < NotificationsSubscriber
 
         PERFORM_ACTION = 'perform_action.action_cable'.freeze
 
-        def start name, id, payload #THREAD_LOCAL_ACCESS
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
           return unless state.is_execution_traced?
-          event = super
-          if event.name == PERFORM_ACTION
-            start_transaction event
+
+          finishable = if name == PERFORM_ACTION
+            Tracer.start_transaction_or_segment(
+              name: transaction_name_from_payload(payload),
+              category: :action_cable
+            )
           else
-            start_recording_metrics event
+            Tracer.start_segment(name: metric_name_from_payload(name, payload))
           end
+          push_segment(id, finishable)
         rescue => e
           log_notification_error e, name, 'start'
         end
 
-        def finish name, id, payload #THREAD_LOCAL_ACCESS
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
           return unless state.is_execution_traced?
-          event = super
-          notice_error payload if payload.key? :exception
-          if event.name == PERFORM_ACTION
-            finish_transaction
-          else
-            stop_recording_metrics event
+
+          if exception = exception_object(payload)
+            NewRelic::Agent.notice_error exception
           end
+
+          finishable = pop_segment(id)
+          finishable.finish if finishable
         rescue => e
           log_notification_error e, name, 'finish'
         end
 
         private
 
-        def start_transaction event
-          Transaction.start(state, :action_cable, :transaction_name => transaction_name_from_event(event))
-        end
-
-        def finish_transaction
-          Transaction.stop(state)
-        end
-
-        def start_recording_metrics event
-          event.payload[:segment] = Transaction.start_segment metric_name_from_event(event)
-        end
-
-        def stop_recording_metrics event
-          event.payload[:segment].finish if event.payload[:segment]
+        def transaction_name_from_payload(payload)
+          "Controller/ActionCable/#{payload[:channel_class]}/#{payload[:action]}"
         end
 
-        def transaction_name_from_event event
-          "Controller/ActionCable/#{event.payload[:channel_class]}/#{event.payload[:action]}"
+        def metric_name_from_payload(name, payload)
+          "Ruby/ActionCable/#{payload[:channel_class]}/#{action_name(name)}"
         end
 
-        def metric_name_from_event event
-          "Ruby/ActionCable/#{event.payload[:channel_class]}/#{action_name_from_event(event)}"
-        end
-
-        DOT_ACTION_CABLE = ".action_cable".freeze
-        EMPTY_STRING = "".freeze
-
-        def action_name_from_event event
-          event.name.gsub DOT_ACTION_CABLE, EMPTY_STRING
-        end
+        DOT_ACTION_CABLE = '.action_cable'.freeze
 
-        def notice_error payload
-          NewRelic::Agent.notice_error payload[:exception_object]
+        def action_name(name)
+          name.gsub DOT_ACTION_CABLE, NewRelic::EMPTY_STR
         end
       end
     end

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

@@ -1,22 +1,24 @@
 # 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'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+require 'new_relic/agent/instrumentation/notifications_subscriber'
 require 'new_relic/agent/instrumentation/ignore_actions'
 require 'new_relic/agent/parameter_filtering'
 
 module NewRelic
   module Agent
     module Instrumentation
-      class ActionControllerSubscriber < EventedSubscriber
+      class ActionControllerSubscriber < NotificationsSubscriber
 
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
-          request = state.request
-          event = ControllerEvent.new(name, Time.now, nil, id, payload, request)
-          push_event(event)
+          # @req is a historically stable but not guaranteed Rails header property
+          request = payload[:headers].instance_variable_get(:@req)
 
-          if state.is_execution_traced? && !event.ignored?
-            start_transaction(event)
+          controller_class = controller_class(payload)
+
+          if state.is_execution_traced? && !should_ignore(payload, controller_class)
+            finishable = start_transaction_or_segment(payload, request, controller_class)
+            push_segment(id, finishable)
           else
             # if this transaction is ignored, make sure child
             # transaction are also ignored
@@ -28,11 +30,16 @@ module NewRelic
         end
 
         def finish(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = pop_event(id)
-          event.payload.merge!(payload)
+          finishable = pop_segment(id)
+
+          if state.is_execution_traced? \
+              && !should_ignore(payload, controller_class(payload))
 
-          if state.is_execution_traced? && !event.ignored?
-            stop_transaction(event)
+            if exception = exception_object(payload)
+              finishable.notice_error(exception)
+            end
+
+            finishable.finish
           else
             Agent.instance.pop_trace_execution_flag
           end
@@ -40,78 +47,52 @@ module NewRelic
           log_notification_error(e, name, 'finish')
         end
 
-        def start_transaction(event)
-          Transaction.start(state, :controller,
-                            :request          => event.request,
-                            :filtered_params  => filter(event.payload[:params]),
-                            :apdex_start_time => event.queue_start,
-                            :transaction_name => event.metric_name)
+        def start_transaction_or_segment(payload, request, controller_class)
+          Tracer.start_transaction_or_segment(
+            name:      format_metric_name(payload[:action], controller_class),
+            category:  :controller,
+            options:   {
+              request:          request,
+              filtered_params:  NewRelic::Agent::ParameterFiltering.filter_using_rails(
+                payload[:params],
+                Rails.application.config.filter_parameters
+              ),
+              apdex_start_time: queue_start(request),
+              ignore_apdex:     NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
+                ControllerInstrumentation::NR_IGNORE_APDEX_KEY,
+                controller_class,
+                payload[:action]
+              ),
+              ignore_enduser:   NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
+                ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY,
+                controller_class,
+                payload[:action]
+              )
+            }
+          )
         end
 
-        def stop_transaction(event)
-          txn = state.current_transaction
-          txn.ignore_apdex!   if event.apdex_ignored?
-          txn.ignore_enduser! if event.enduser_ignored?
-          Transaction.stop(state)
-        end
-
-        def filter(params)
-          munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(params)
-          filters = Rails.application.config.filter_parameters
-          ActionDispatch::Http::ParameterFilter.new(filters).filter(munged_params)
-        end
-      end
-
-      class ControllerEvent < Event
-        attr_accessor :parent
-        attr_reader :queue_start, :request
-
-        def initialize(name, start, ending, transaction_id, payload, request)
-          # We have a different initialize parameter list, so be explicit
-          super(name, start, ending, transaction_id, payload)
-
-          @request = request
-          @controller_class = payload[:controller].split('::') \
-            .inject(Object){|m,o| m.const_get(o)}
-
-          if request && request.respond_to?(:env)
-            @queue_start = QueueTime.parse_frontend_timestamp(request.env, self.time)
-          end
+        def format_metric_name(metric_action, controller_name)
+          controller_class = ::NewRelic::LanguageSupport.constantize(controller_name)
+          "Controller/#{controller_class.controller_path}/#{metric_action}"
         end
 
-        def metric_name
-          @metric_name || "Controller/#{metric_path}/#{metric_action}"
+        def controller_class(payload)
+          ::NewRelic::LanguageSupport.constantize(payload[:controller])
         end
 
-        def metric_path
-          @controller_class.controller_path
-        end
-
-        def metric_action
-          payload[:action]
-        end
-
-        def ignored?
-          _is_filtered?(ControllerInstrumentation::NR_DO_NOT_TRACE_KEY)
-        end
-
-        def apdex_ignored?
-          _is_filtered?(ControllerInstrumentation::NR_IGNORE_APDEX_KEY)
-        end
-
-        def enduser_ignored?
-          _is_filtered?(ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY)
-        end
-
-        def _is_filtered?(key)
+        def should_ignore(payload, controller_class)
           NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
-            key,
-            @controller_class,
-            metric_action)
+            ControllerInstrumentation::NR_DO_NOT_TRACE_KEY,
+            controller_class,
+            payload[:action]
+          )
         end
 
-        def to_s
-          "#<NewRelic::Agent::Instrumentation::ControllerEvent:#{object_id} name: \"#{name}\" id: #{transaction_id} payload: #{payload}}>"
+        def queue_start(request)
+          if request && request.respond_to?(:env)
+            QueueTime.parse_frontend_timestamp(request.env, Time.now)
+          end
         end
       end
     end

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

@@ -1,87 +1,113 @@
 # 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'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+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::Transaction.start_segment 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
+          if segment = pop_segment(id)
+
+          if exception = exception_object(payload)
+            segment.notice_error exception
+          end
+            segment.finish
+          end
         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
-
-          # 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"
-          end
+        def format_metric_name(event_name, payload, parent)
+          return parent.name if parent \
+             && (payload[:virtual_path] \
+              || (parent.identifier =~ /template$/))
 
-          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
-
-            # memoize
-            @metric_name ||= "View/#{metric_path(name, identifier)}/#{metric_action(name)}"
-            @metric_name
+          if payload.key?(:virtual_path)
+            identifier = payload[:virtual_path]
+          else
+            identifier = payload[:identifier]
           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
+          "View/#{metric_path(event_name, identifier)}/#{metric_action(event_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_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
+
+        def notice_error error
+          @finishable.notice_error error if @finishable
+        end
+      end
     end
+
   end
 end

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

@@ -1,6 +1,8 @@
 # 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.
+
+require 'new_relic/agent/prepend_supportability'
 
 DependencyDetection.defer do
   named :activejob
@@ -12,12 +14,16 @@ DependencyDetection.defer do
   executes do
     ::NewRelic::Agent.logger.info 'Installing ActiveJob instrumentation'
 
-    ::ActiveJob::Base.around_enqueue do |job, block|
-      ::NewRelic::Agent::Instrumentation::ActiveJobHelper.enqueue(job, block)
-    end
+    ActiveSupport.on_load(:active_job) do
+      ::ActiveJob::Base.around_enqueue do |job, block|
+        ::NewRelic::Agent::Instrumentation::ActiveJobHelper.enqueue(job, block)
+      end
+
+      ::ActiveJob::Base.around_perform do |job, block|
+        ::NewRelic::Agent::Instrumentation::ActiveJobHelper.perform(job, block)
+      end
 
-    ::ActiveJob::Base.around_perform do |job, block|
-      ::NewRelic::Agent::Instrumentation::ActiveJobHelper.perform(job, block)
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActiveJob::Base)
     end
   end
 end
@@ -33,19 +39,20 @@ module NewRelic
         end
 
         def self.perform(job, block)
-          state = ::NewRelic::Agent::TransactionState.tl_get
+          state = ::NewRelic::Agent::Tracer.state
+          txn = state.current_transaction
 
           # Don't nest transactions if we're already in a web transaction.
           # Probably inline processing the job if that happens, so just trace.
-          if state.in_web_transaction?
+          if    txn &&  txn.recording_web_transaction?
             run_in_trace(job, block, :Consume)
-          elsif state.in_background_transaction?
+          elsif txn && !txn.recording_web_transaction?
             ::NewRelic::Agent::Transaction.set_default_transaction_name(
               transaction_name_suffix_for_job(job),
               transaction_category)
             block.call
           else
-            run_in_transaction(state, job, block)
+            run_in_transaction(job, block)
           end
         end
 
@@ -55,11 +62,10 @@ module NewRelic
           end
         end
 
-        def self.run_in_transaction(state, job, block)
-          ::NewRelic::Agent::Transaction.wrap(state,
-                                              transaction_name_for_job(job),
-                                              :other,
-                                              &block)
+        def self.run_in_transaction(job, block)
+          ::NewRelic::Agent::Tracer.in_transaction(name: transaction_name_for_job(job),
+                                                   category: :other,
+                                                   &block)
         end
 
         def self.transaction_category