newrelic_rpm 4.8.0.341 → 6.13.1

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/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'
 
@@ -14,15 +14,17 @@ 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)
+      end
 
-    ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActiveJob::Base)
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActiveJob::Base)
+    end
   end
 end
 
@@ -37,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
 
@@ -59,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

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.
 
 DependencyDetection.defer do
   @name = :active_merchant

data/lib/new_relic/agent/instrumentation/active_record.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/instrumentation/active_record_prepend'
 
@@ -43,44 +43,91 @@ module NewRelic
           end
         end
 
-        def log_with_newrelic_instrumentation(*args, &block) #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
-
-          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]
+        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)
+  
+            begin
+              NewRelic::Agent::Tracer.capture_segment_error segment do
+                log_without_newrelic_instrumentation(*args, &block)
+              end
+            ensure
+              segment.finish if segment
+            end
           end
-
-          segment = NewRelic::Agent::Transaction.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)
-
-          begin
-            log_without_newrelic_instrumentation(*args, &block)
-          ensure
-            segment.finish if segment
+        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
+  
+            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)
+  
+            begin
+              NewRelic::Agent::Tracer.capture_segment_error segment do
+                log_without_newrelic_instrumentation(*args, **kwargs, &block)
+              end
+            ensure
+              segment.finish if segment
+            end
           end
         end
       end

data/lib/new_relic/agent/instrumentation/active_record_helper.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/datastores/metric_helper'
 
@@ -19,20 +19,38 @@ module NewRelic
         def instrument_save_methods
           ::ActiveRecord::Base.class_eval do
             alias_method :save_without_newrelic, :save
-
-            def save(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
-                save_without_newrelic(*args, &blk)
+            
+            if RUBY_VERSION < "2.7.0"
+              def save(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                  save_without_newrelic(*args, &blk)
+                end
+              end
+            else
+              def save(*args, **kwargs, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                  save_without_newrelic(*args, **kwargs, &blk)
+                end
               end
+
             end
 
             alias_method :save_without_newrelic!, :save!
 
-            def save!(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
-                save_without_newrelic!(*args, &blk)
+            if RUBY_VERSION < "2.7.0"
+              def save!(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                  save_without_newrelic!(*args, &blk)
+                end
+              end
+            else
+              def save!(*args, **kwargs, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                  save_without_newrelic!(*args, **kwargs, &blk)
+                end
               end
             end
+
           end
         end
 
@@ -40,42 +58,82 @@ module NewRelic
           ::ActiveRecord::Relation.class_eval do
             alias_method :update_all_without_newrelic, :update_all
 
-            def update_all(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                update_all_without_newrelic(*args, &blk)
+            if RUBY_VERSION < "2.7.0"
+              def update_all(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  update_all_without_newrelic(*args, &blk)
+                end
+              end
+            else
+              def update_all(*args, **kwargs, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  update_all_without_newrelic(*args, **kwargs, &blk)
+                end
               end
             end
-
+            
             alias_method :delete_all_without_newrelic, :delete_all
 
-            def delete_all(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                delete_all_without_newrelic(*args, &blk)
+            if RUBY_VERSION < "2.7.0"
+              def delete_all(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  delete_all_without_newrelic(*args, &blk)
+                end
+              end
+            else
+              def delete_all(*args, **kwargs, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  delete_all_without_newrelic(*args, **kwargs, &blk)
+                end
               end
             end
 
             alias_method :destroy_all_without_newrelic, :destroy_all
 
-            def destroy_all(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                destroy_all_without_newrelic(*args, &blk)
+            if RUBY_VERSION < "2.7.0"
+              def destroy_all(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  destroy_all_without_newrelic(*args, &blk)
+                end
+              end
+            else
+              def destroy_all(*args, **kwargs, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  destroy_all_without_newrelic(*args, **kwargs, &blk)
+                end
               end
             end
 
             alias_method :calculate_without_newrelic, :calculate
 
-            def calculate(*args, &blk)
-              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                calculate_without_newrelic(*args, &blk)
+            if RUBY_VERSION < "2.7.0"
+              def calculate(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  calculate_without_newrelic(*args, &blk)
+                end
+              end
+            else
+              def calculate(*args, **kwargs, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  calculate_without_newrelic(*args, **kwargs, &blk)
+                end
               end
             end
 
             if method_defined?(:pluck)
               alias_method :pluck_without_newrelic, :pluck
 
-              def pluck(*args, &blk)
-                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-                  pluck_without_newrelic(*args, &blk)
+              if RUBY_VERSION < "2.7.0"
+                def pluck(*args, &blk)
+                  ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                    pluck_without_newrelic(*args, &blk)
+                  end
+                end
+              else
+                def pluck(*args, **kwargs, &blk)
+                  ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                    pluck_without_newrelic(*args, **kwargs, &blk)
+                  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/newrelic-ruby-agent/blob/main/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