newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -1,93 +1,109 @@
-# 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.
+# frozen_string_literal: true
+
+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
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = RenderEvent.new(name, Time.now, nil, id, payload)
-          push_event(event)
+      class ActionViewSubscriber < NotificationsSubscriber
+        def start_segment(name, id, payload)
+          parent = segment_stack[id].last
+          metric_name = format_metric_name(name, payload, parent)
 
-          state = NewRelic::Agent::TransactionState.tl_get
+          event = ActionViewEvent.new(metric_name, payload[:identifier])
 
-          if state.is_execution_traced? && event.recordable?
-            stack = state.traced_method_stack
-            event.frame = stack.push_frame(state, :action_view, event.time)
+          if recordable?(name, metric_name)
+            event.finishable = Tracer.start_segment(name: metric_name)
           end
-        rescue => e
-          log_notification_error(e, name, 'start')
+          push_segment(id, event)
         end
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
-          event = pop_event(id)
+        def finish_segment(id, payload)
+          if segment = pop_segment(id)
+            if exception = exception_object(payload)
+              segment.notice_error(exception)
+            end
+            segment.finish
+          end
+        end
 
-          state = NewRelic::Agent::TransactionState.tl_get
+        def format_metric_name(event_name, payload, parent)
+          return parent.name if parent \
+             && (payload[:virtual_path] \
+              || (parent.identifier =~ /template$/))
 
-          if state.is_execution_traced? && event.recordable?
-            stack = state.traced_method_stack
-            frame = stack.pop_frame(state, event.frame, event.metric_name, event.end)
-            record_metrics(event, frame)
+          if payload.key?(:virtual_path)
+            identifier = payload[:virtual_path]
+          else
+            identifier = payload[:identifier]
           end
-        rescue => e
-          log_notification_error(e, name, 'finish')
-        end
 
-        def record_metrics(event, frame) #THREAD_LOCAL_ACCESS
-          exclusive = event.duration - frame.children_time
-          NewRelic::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
-            event.metric_name, nil, event.duration, exclusive)
+          "View/#{metric_path(event_name, identifier)}/#{metric_action(event_name)}"
         end
 
-        class RenderEvent < Event
-          # 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
+        # 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
 
-          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
+        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
 
-            # memoize
-            @metric_name ||= "View/#{metric_path(identifier)}/#{metric_action(name)}"
-            @metric_name
+        def metric_action(name)
+          case name
+          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
 
-          def metric_path(identifier)
-            if identifier == nil
-              'file'
-            elsif identifier =~ /template$/
-              identifier
-            elsif (parts = identifier.split('/')).size > 1
-              parts[-2..-1].join('/')
-            else
-              ::NewRelic::Agent::UNKNOWN_METRIC
-            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 /template$/.match?(identifier)
+            identifier
+          elsif identifier && (parts = identifier.split('/')).size > 1
+            parts[-2..-1].join('/')
+          else
+            ::NewRelic::Agent::UNKNOWN_METRIC
           end
+        end
+      end
 
-          def metric_action(name)
-            case name
-            when /render_template.action_view$/  then 'Rendering'
-            when 'render_partial.action_view'    then 'Partial'
-            when 'render_collection.action_view' then 'Partial'
-            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
+        end
+
+        def notice_error(error)
+          @finishable&.notice_error(error)
         end
       end
     end

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

@@ -1,23 +1,42 @@
-# 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.
+# frozen_string_literal: true
+
+require 'new_relic/agent/prepend_supportability'
 
 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)
+      end
 
-    ::ActiveJob::Base.around_enqueue do |job, block|
-      ::NewRelic::Agent::Instrumentation::ActiveJobHelper.enqueue(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)
     end
+  end
 
-    ::ActiveJob::Base.around_perform do |job, block|
-      ::NewRelic::Agent::Instrumentation::ActiveJobHelper.perform(job, block)
+  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
@@ -33,33 +52,40 @@ 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&.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)
+              transaction_category
+            )
             block.call
           else
-            run_in_transaction(state, job, block)
+            run_in_transaction(job, block)
           end
         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(state, job, block)
-          ::NewRelic::Agent::Transaction.wrap(state,
-                                              transaction_name_for_job(job),
-                                              :other,
-                                              &block)
+        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, options: options, &block)
+        end
+
+        def self.code_information_for_job(job)
+          NewRelic::Agent::MethodTracerHelpers.code_information(job.class, :perform)
         end
 
         def self.transaction_category
@@ -75,7 +101,13 @@ module NewRelic
         end
 
         def self.adapter
-          clean_adapter_name(::ActiveJob::Base.queue_adapter.name)
+          adapter_class = if ::ActiveJob::Base.queue_adapter.class == Class
+            ::ActiveJob::Base.queue_adapter
+          else
+            ::ActiveJob::Base.queue_adapter.class
+          end
+
+          clean_adapter_name(adapter_class.name)
         end
 
         ADAPTER_REGEX = /ActiveJob::QueueAdapters::(.*)Adapter/

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

data/lib/new_relic/agent/instrumentation/active_merchant.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.
+# frozen_string_literal: true
 
 DependencyDetection.defer do
   @name = :active_merchant
@@ -12,7 +12,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveMerchant instrumentation'
+    NewRelic::Agent.logger.info('Installing ActiveMerchant instrumentation')
   end
 
   executes do
@@ -24,14 +24,28 @@ DependencyDetection.defer do
       gateway.class_eval do
         implemented_methods = public_instance_methods(false).map(&:to_sym)
         gateway_name = self.name.split('::').last
-        [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update].each do |operation|
+        actions = [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update]
+        actions.each do |operation|
           if implemented_methods.include?(operation)
-            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}"
-            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}", :push_scope => false
-            add_method_tracer operation, "ActiveMerchant/operation/#{operation}", :push_scope => false
+            add_method_tracer operation, [->(*) { "ActiveMerchant/gateway/#{gateway_name}/#{operation}" },
+              ->(*) { "ActiveMerchant/gateway/#{gateway_name}" },
+              ->(*) { "ActiveMerchant/operation/#{operation}" }]
           end
         end
       end
     end
   end
+
+  executes do
+    next unless Gem::Version.new(ActiveMerchant::VERSION) < Gem::Version.new('1.65.0')
+
+    deprecation_msg = 'The Ruby agent is dropping support for ActiveMerchant versions below 1.65.0 ' \
+      'in version 9.0.0. Please upgrade your ActiveMerchant version to continue receiving full support. ' \
+
+    NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_active_merchant_version,
+      deprecation_msg
+    )
+  end
 end

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

@@ -1,22 +1,34 @@
-# 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.
+# frozen_string_literal: true
+
+require 'new_relic/agent/instrumentation/active_record_prepend'
 
 module NewRelic
   module Agent
     module Instrumentation
       module ActiveRecord
-        EXPLAINER = lambda do |config, query|
-          connection = NewRelic::Agent::Database.get_connection(config) do
-            ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
-                                      config)
+        EXPLAINER = lambda do |statement|
+          connection = NewRelic::Agent::Database.get_connection(statement.config) do
+            ::ActiveRecord::Base.send("#{statement.config[:adapter]}_connection",
+              statement.config)
           end
-          if connection && connection.respond_to?(:execute)
-            return connection.execute("EXPLAIN #{query}")
+          # the following line needs else branch coverage
+          if connection && connection.respond_to?(:execute) # rubocop:disable Style/SafeNavigation
+            return connection.execute("EXPLAIN #{statement.sql}")
           end
         end
 
         def self.insert_instrumentation
+          if defined?(::ActiveRecord::VERSION::MAJOR) && ::ActiveRecord::VERSION::MAJOR.to_i >= 3
+            if ::NewRelic::Agent.config[:prepend_active_record_instrumentation]
+              ::ActiveRecord::Base.prepend(::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
+              ::ActiveRecord::Relation.prepend(::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
+            else
+              ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
+            end
+          end
+
           ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
             include ::NewRelic::Agent::Instrumentation::ActiveRecord
           end
@@ -25,43 +37,99 @@ module NewRelic
         def self.included(instrumented_class)
           instrumented_class.class_eval do
             unless instrumented_class.method_defined?(:log_without_newrelic_instrumentation)
-              alias_method :log_without_newrelic_instrumentation, :log
-              alias_method :log, :log_with_newrelic_instrumentation
-              protected :log
+              alias_method(:log_without_newrelic_instrumentation, :log)
+              alias_method(:log, :log_with_newrelic_instrumentation)
+              protected(:log)
             end
           end
         end
 
-        def log_with_newrelic_instrumentation(*args, &block) #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
+        if RUBY_VERSION < '2.7.0'
+          def log_with_newrelic_instrumentation(*args, &block)
+            state = NewRelic::Agent::Tracer.state
+
+            if !state.is_execution_traced?
+              return log_without_newrelic_instrumentation(*args, &block)
+            end
+
+            sql, name, _ = args
+
+            product, operation, collection = ActiveRecordHelper.product_operation_collection_for(
+              NewRelic::Helper.correctly_encoded(name),
+              NewRelic::Helper.correctly_encoded(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 = NewRelic::Agent::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)
 
-          if !state.is_execution_traced?
-            return log_without_newrelic_instrumentation(*args, &block)
+            begin
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                log_without_newrelic_instrumentation(*args, &block)
+              end
+            ensure
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
+            end
           end
+        else
+          def log_with_newrelic_instrumentation(*args, **kwargs, &block)
+            state = NewRelic::Agent::Tracer.state
+
+            if !state.is_execution_traced?
+              return log_without_newrelic_instrumentation(*args, **kwargs, &block)
+            end
 
-          sql, name, _ = args
-          metrics = ActiveRecordHelper.metrics_for(
-            NewRelic::Helper.correctly_encoded(name),
-            NewRelic::Helper.correctly_encoded(sql),
-            @config && @config[:adapter])
+            sql, name, _ = args
 
-          # It is critical that we grab this name before trace_execution_scoped
-          # because that method mutates the metrics list passed in.
-          scoped_metric = metrics.first
+            product, operation, collection = ActiveRecordHelper.product_operation_collection_for(
+              NewRelic::Helper.correctly_encoded(name),
+              NewRelic::Helper.correctly_encoded(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 = NewRelic::Agent::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)
 
-          NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
-            t0 = Time.now
             begin
-              log_without_newrelic_instrumentation(*args, &block)
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                log_without_newrelic_instrumentation(*args, **kwargs, &block)
+              end
             ensure
-              elapsed_time = (Time.now - t0).to_f
-
-              NewRelic::Agent.instance.transaction_sampler.notice_sql(sql,
-                                                    @config, elapsed_time,
-                                                    state, &EXPLAINER)
-              NewRelic::Agent.instance.sql_sampler.notice_sql(sql, scoped_metric,
-                                                    @config, elapsed_time,
-                                                    state, &EXPLAINER)
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
             end
           end
         end
@@ -74,26 +142,28 @@ DependencyDetection.defer do
   @name = :active_record
 
   depends_on do
-    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
-      (!defined?(::ActiveRecord::VERSION) ||
-        ::ActiveRecord::VERSION::MAJOR.to_i <= 3)
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+      (!defined?(ActiveRecord::VERSION) ||
+        ActiveRecord::VERSION::MAJOR.to_i <= 3)
   end
 
   depends_on do
-    !NewRelic::Agent.config[:disable_activerecord_instrumentation]
+    !NewRelic::Agent.config[:disable_active_record_instrumentation]
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveRecord instrumentation'
+    NewRelic::Agent.logger.info('Installing ActiveRecord instrumentation')
   end
 
   executes do
-    if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+    require 'new_relic/agent/instrumentation/active_record_helper'
+
+    if defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR.to_i == 3
       ActiveSupport.on_load(:active_record) do
-        ::NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
+        NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
       end
     else
-      ::NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
+      NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
     end
   end
 end