newrelic_rpm 8.2.0 → 9.0.0

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

@@ -0,0 +1,39 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+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 ActionControllerOtherSubscriber < NotificationsSubscriber
+        def add_segment_params(segment, payload)
+          segment.params[:filter] = payload[:filter] if payload[:filter]
+          segment.params[:keys] = payload[:keys] if payload[:keys]
+          segment.params[:original_path] = payload[:request].original_fullpath if payload[:request]
+
+          if payload[:context]
+            segment.params[:action] = payload[:context][:action]
+            segment.params[:controller] = payload[:context][:controller]
+          end
+        end
+
+        def metric_name(name, payload)
+          controller_name = controller_name_for_metric(payload)
+          "Ruby/ActionController#{"/#{controller_name}" if controller_name}/#{name.gsub(/\.action_controller/, '')}"
+        end
+
+        def controller_name_for_metric(payload)
+          # redirect_to
+          return payload[:request].controller_class.controller_path if payload[:request] && payload[:request].controller_class
+
+          # unpermitted_parameters
+          ::NewRelic::LanguageSupport.constantize(payload[:context][:controller]).controller_path if payload[:context] && payload[:context][:controller]
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
 require 'new_relic/agent/instrumentation/notifications_subscriber'
 require 'new_relic/agent/instrumentation/ignore_actions'
 require 'new_relic/agent/parameter_filtering'
@@ -9,15 +10,11 @@ module NewRelic
   module Agent
     module Instrumentation
       class ActionControllerSubscriber < NotificationsSubscriber
-
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
-          # @req is a historically stable but not guaranteed Rails header property
-          request = payload[:headers].instance_variable_get(:@req)
-
+        def start(name, id, payload) # THREAD_LOCAL_ACCESS
           controller_class = controller_class(payload)
 
           if state.is_execution_traced? && !should_ignore(payload, controller_class)
-            finishable = start_transaction_or_segment(payload, request, controller_class)
+            finishable = start_transaction_or_segment(payload, request_for_payload(payload), controller_class)
             push_segment(id, finishable)
           else
             # if this transaction is ignored, make sure child
@@ -29,7 +26,7 @@ module NewRelic
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+        def finish(name, id, payload) # THREAD_LOCAL_ACCESS
           finishable = pop_segment(id)
 
           if state.is_execution_traced? \
@@ -49,31 +46,34 @@ module NewRelic
 
         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]
-              )
-            }
+            name: format_metric_name(payload[:action], controller_class),
+            category: :controller,
+            options: tracer_options(payload, request, controller_class)
           )
         end
 
-        def format_metric_name(metric_action, controller_name)
-          controller_class = ::NewRelic::LanguageSupport.constantize(controller_name)
+        def tracer_options(payload, request, controller_class)
+          {
+            request: request,
+            filtered_params: filtered_params(payload[:params]),
+            apdex_start_time: queue_start(request),
+            ignore_apdex: ignore?(payload[:action], ControllerInstrumentation::NR_IGNORE_APDEX_KEY, controller_class),
+            ignore_enduser: ignore?(payload[:action],
+              ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY,
+              controller_class)
+          }.merge(NewRelic::Agent::MethodTracerHelpers.code_information(controller_class, payload[:action]))
+        end
+
+        def filtered_params(params)
+          NewRelic::Agent::ParameterFiltering.filter_using_rails(params, Rails.application.config.filter_parameters)
+        end
+
+        def ignore?(action, key, controller_class)
+          NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(key, controller_class, action)
+        end
+
+        def format_metric_name(metric_action, controller)
+          controller_class = controller.is_a?(Class) ? controller : Object.const_get(controller)
           "Controller/#{controller_class.controller_path}/#{metric_action}"
         end
 
@@ -94,6 +94,13 @@ module NewRelic
             QueueTime.parse_frontend_timestamp(request.env, Process.clock_gettime(Process::CLOCK_REALTIME))
           end
         end
+
+        def request_for_payload(payload)
+          # @req is a historically stable but not guaranteed Rails header property
+          return unless payload[:headers].instance_variables.include?(:@req)
+
+          payload[:headers].instance_variable_get(:@req)
+        end
       end
     end
   end

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

@@ -0,0 +1,31 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/instrumentation/action_dispatch_subscriber'
+
+DependencyDetection.defer do
+  named :action_dispatch
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_action_dispatch]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      defined?(ActionDispatch) &&
+      defined?(ActionPack) &&
+      ActionPack.respond_to?(:gem_version) &&
+      ActionPack.gem_version >= Gem::Version.new('6.0.0') && # notifications for dispatch added in Rails 6
+      !NewRelic::Agent::Instrumentation::ActionDispatchSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActionDispatch instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\A[^\.]+\.action_dispatch\z/,
+      NewRelic::Agent::Instrumentation::ActionDispatchSubscriber.new)
+  end
+end

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

@@ -0,0 +1,64 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/instrumentation/notifications_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionDispatchSubscriber < NotificationsSubscriber
+        def start(name, id, payload)
+          return unless state.is_execution_traced?
+
+          start_segment(name, id, payload)
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload)
+          return unless state.is_execution_traced?
+
+          finish_segment(id, payload)
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def start_segment(name, id, payload)
+          segment = Tracer.start_segment(name: metric_name(name, payload))
+          push_segment(id, segment)
+        end
+
+        def finish_segment(id, payload)
+          if segment = pop_segment(id)
+            if exception = exception_object(payload)
+              segment.notice_error(exception)
+            end
+            segment.finish
+          end
+        end
+
+        def metric_name(name, payload)
+          middleware = payload[:middleware]
+          method = method_from_name(name)
+          "Ruby/ActionDispatch/#{middleware}/#{method}"
+        end
+
+        PATTERN = /\A([^\.]+)\.action_dispatch\z/
+        UNKNOWN = 'unknown'.freeze
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = UNKNOWN
+          end
+        end
+
+        def method_from_name(name)
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/instrumentation/action_mailbox_subscriber'
+
+DependencyDetection.defer do
+  named :action_mailbox
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_action_mailbox]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      defined?(ActionMailbox) &&
+      ActionMailbox.respond_to?(:gem_version) && # 'require "action_mailbox"' doesn't require version...
+      ActionMailbox.gem_version >= Gem::Version.new('7.1.0.alpha') && # notifications added in Rails 7.1
+      !NewRelic::Agent::Instrumentation::ActionMailboxSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActionMailbox instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\A[^\.]+\.action_mailbox\z/,
+      NewRelic::Agent::Instrumentation::ActionMailboxSubscriber.new)
+  end
+end

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

@@ -0,0 +1,33 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/instrumentation/notifications_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActionMailboxSubscriber < NotificationsSubscriber
+        def metric_name(name, payload)
+          mailbox = payload[:mailbox].class.name
+          method = method_from_name(name)
+          "Ruby/ActionMailbox/#{mailbox}/#{method}"
+        end
+
+        PATTERN = /\A([^\.]*)\.action_mailbox\z/
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = NewRelic::UNKNOWN
+          end
+        end
+
+        def method_from_name(name)
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/instrumentation/action_mailer_subscriber'
+
+DependencyDetection.defer do
+  named :action_mailer
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_action_mailer]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      defined?(ActionMailer) &&
+      ActionMailer.respond_to?(:gem_version) &&
+      ActionMailer.gem_version >= Gem::Version.new('5.0') &&
+      !NewRelic::Agent::Instrumentation::ActionMailerSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActionMailer instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\A(?:[^\.]+)\.action_mailer\z/,
+      NewRelic::Agent::Instrumentation::ActionMailerSubscriber.new)
+  end
+end

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

@@ -0,0 +1,85 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/instrumentation/notifications_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      # NOTE: as of v7.1.0.0.alpha, deliver.action_mailer will provide
+      # an empty payload hash ({}) to #start, so in this subscriber class
+      # we defer params population until #finish and start the segment with
+      # a temporary name that is later replaced
+      class ActionMailerSubscriber < NotificationsSubscriber
+        BASE_NAME = 'Ruby/ActionMailer'
+        PAYLOAD_KEYS = %i[action data key mailer message_id perform_deliveries subject]
+        PATTERN = /\A([^\.]+)\.action_mailer\z/
+        UNKNOWN_MAILER = %r{^#{BASE_NAME}/#{UNKNOWN}/}
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = NewRelic::UNKNOWN
+          end
+        end
+
+        def start(name, id, payload)
+          return unless state.is_execution_traced?
+
+          start_segment(name, id, payload)
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload)
+          return unless state.is_execution_traced?
+
+          finish_segment(id, payload)
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        private
+
+        def start_segment(name, id, payload)
+          segment = Tracer.start_segment(name: metric_name(name, payload))
+          push_segment(id, segment)
+        end
+
+        def finish_segment(id, payload)
+          segment = pop_segment(id)
+          return unless segment
+
+          if segment.name.match?(UNKNOWN_MAILER) && payload.key?(:mailer)
+            segment.name = segment.name.sub(UNKNOWN_MAILER, "#{BASE_NAME}/#{payload[:mailer]}/")
+          end
+
+          PAYLOAD_KEYS.each do |key|
+            segment.params[key] = payload[key] if payload.key?(key)
+          end
+
+          notice_exception(segment, payload)
+          segment.finish
+        end
+
+        def notice_exception(segment, payload)
+          if exception = exception_object(payload)
+            segment.notice_error(exception)
+          end
+        end
+
+        def metric_name(name, payload)
+          mailer = payload[:mailer] || UNKNOWN
+          method = method_from_name(name)
+          "#{BASE_NAME}/#{mailer}/#{method}"
+        end
+
+        def method_from_name(name)
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
 require 'new_relic/agent/instrumentation/notifications_subscriber'
 
 # Listen for ActiveSupport::Notifications events for ActionView render
@@ -9,29 +10,25 @@ module NewRelic
   module Agent
     module Instrumentation
       class ActionViewSubscriber < NotificationsSubscriber
-
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+        def start_segment(name, id, payload)
           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)
+
+          if 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')
+          push_segment(id, event)
         end
 
-        def finish(name, id, payload)
+        def finish_segment(id, payload)
           if segment = pop_segment(id)
             if exception = exception_object(payload)
-              segment.notice_error exception
+              segment.notice_error(exception)
             end
             segment.finish
           end
-        rescue => e
-          log_notification_error(e, name, 'finish')
         end
 
         def format_metric_name(event_name, payload, parent)
@@ -58,15 +55,18 @@ module NewRelic
               || 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_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
+        RENDER_LAYOUT_EVENT_NAME = 'render_layout.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'
+          when /#{RENDER_TEMPLATE_EVENT_NAME}$/o then 'Rendering'
+          when RENDER_PARTIAL_EVENT_NAME then 'Partial'
+          when RENDER_COLLECTION_EVENT_NAME then 'Partial'
+          when RENDER_LAYOUT_EVENT_NAME then 'Layout'
+          else NewRelic::UNKNOWN
           end
         end
 
@@ -102,11 +102,10 @@ module NewRelic
           @finishable.finish if @finishable
         end
 
-        def notice_error error
-          @finishable.notice_error error if @finishable
+        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,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/prepend_supportability'
 
@@ -8,22 +8,35 @@ DependencyDetection.defer do
   named :activejob
 
   depends_on do
-    defined?(::ActiveJob::Base)
+    defined?(ActiveJob::Base)
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveJob instrumentation'
+    NewRelic::Agent.logger.info('Installing base ActiveJob instrumentation')
 
     ActiveSupport.on_load(:active_job) do
-      ::ActiveJob::Base.around_enqueue do |job, block|
-        ::NewRelic::Agent::Instrumentation::ActiveJobHelper.enqueue(job, block)
+      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)
+      ActiveJob::Base.around_perform do |job, block|
+        NewRelic::Agent::Instrumentation::ActiveJobHelper.perform(job, block)
       end
 
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActiveJob::Base)
+      NewRelic::Agent::PrependSupportability.record_metrics_for(ActiveJob::Base)
+    end
+  end
+
+  executes do
+    if defined?(ActiveSupport) &&
+        ActiveJob.respond_to?(:gem_version) &&
+        ActiveJob.gem_version >= Gem::Version.new('6.0.0') &&
+        !NewRelic::Agent.config[:disable_activejob] &&
+        !NewRelic::Agent::Instrumentation::ActiveJobSubscriber.subscribed?
+      NewRelic::Agent.logger.info('Installing notifications based ActiveJob instrumentation')
+
+      ActiveSupport::Notifications.subscribe(/\A[^\.]+\.active_job\z/,
+        NewRelic::Agent::Instrumentation::ActiveJobSubscriber.new)
     end
   end
 end
@@ -44,12 +57,13 @@ module NewRelic
 
           # Don't nest transactions if we're already in a web transaction.
           # Probably inline processing the job if that happens, so just trace.
-          if    txn &&  txn.recording_web_transaction?
+          if txn && txn.recording_web_transaction?
             run_in_trace(job, block, :Consume)
           elsif txn && !txn.recording_web_transaction?
             ::NewRelic::Agent::Transaction.set_default_transaction_name(
               transaction_name_suffix_for_job(job),
-              transaction_category)
+              transaction_category
+            )
             block.call
           else
             run_in_transaction(job, block)
@@ -57,15 +71,21 @@ module NewRelic
         end
 
         def self.run_in_trace(job, block, event)
-          trace_execution_scoped("MessageBroker/#{adapter}/Queue/#{event}/Named/#{job.queue_name}") do
+          trace_execution_scoped("ActiveJob/#{adapter.sub(/^ActiveJob::/, '')}/Queue/#{event}/Named/#{job.queue_name}",
+            code_information: code_information_for_job(job)) do
             block.call
           end
         end
 
         def self.run_in_transaction(job, block)
+          options = code_information_for_job(job)
+          options = {} if options.frozen? # the hash will be added to later
           ::NewRelic::Agent::Tracer.in_transaction(name: transaction_name_for_job(job),
-                                                   category: :other,
-                                                   &block)
+            category: :other, options: options, &block)
+        end
+
+        def self.code_information_for_job(job)
+          NewRelic::Agent::MethodTracerHelpers.code_information(job.class, :perform)
         end
 
         def self.transaction_category

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

@@ -0,0 +1,41 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/instrumentation/notifications_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActiveJobSubscriber < NotificationsSubscriber
+        PAYLOAD_KEYS = %i[adapter db_runtime error job wait]
+
+        def add_segment_params(segment, payload)
+          PAYLOAD_KEYS.each do |key|
+            segment.params[key] = payload[key] if payload.key?(key)
+          end
+        end
+
+        def metric_name(name, payload)
+          queue = payload[:job].queue_name
+          method = method_from_name(name)
+          "Ruby/ActiveJob/#{queue}/#{method}"
+        end
+
+        PATTERN = /\A([^\.]+)\.active_job\z/
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = NewRelic::UNKNOWN
+          end
+        end
+
+        def method_from_name(name)
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end