newrelic_rpm 4.8.0.341 → 6.13.1

data/lib/new_relic/agent/instrumentation/active_record_prepend.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'
 
@@ -11,51 +11,122 @@ module NewRelic
         ACTIVE_RECORD = 'ActiveRecord'.freeze
 
         module BaseExtensions
-          def save(*args, &blk)
-            ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
-              super
+
+          if RUBY_VERSION < "2.7.0"
+            def save(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+            def save!(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
             end
-          end
 
-          def save!(*args, &blk)
-            ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
-              super
+          else
+            def save(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
             end
+            def save!(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end  
+
           end
         end
 
-        module RelationExtensions
-          def update_all(*args, &blk)
-            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-              super
+        module BaseExtensions516
+          # In ActiveRecord v5.0.0 through v5.1.5, touch() will call
+          # update_all() and cause us to record a transaction.
+          # Starting in v5.1.6, this call no longer happens. We'll
+          # have to set the database metrics explicitly now.
+          #
+          if RUBY_VERSION < "2.7.0"
+            def touch(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
             end
-          end
-
-          def delete_all(*args, &blk)
-            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-              super
+          else
+            def touch(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
             end
           end
 
-          def destroy_all(*args, &blk)
-            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-              super
-            end
-          end
+        end
 
-          def calculate(*args, &blk)
-            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-              super
+        module RelationExtensions
+          if RUBY_VERSION < "2.7.0"
+            def update_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
             end
-          end
-
-          def pluck(*args, &blk)
-            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
-              super
+  
+            def delete_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+  
+            def destroy_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+  
+            def calculate(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+  
+            def pluck(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+            
+          else
+            def update_all(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
             end
+  
+            def delete_all(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+  
+            def destroy_all(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+  
+            def calculate(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+  
+            def pluck(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+
           end
         end
       end
     end
   end
-end
+end

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

@@ -1,8 +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/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,7 +31,8 @@ module NewRelic
           # we don't expect this to be called more than once, but we're being
           # defensive.
           return if defined?(cached?)
-          if ::ActiveRecord::VERSION::STRING >= "5.1.0"
+
+          if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::STRING >= "5.1.0"
             def cached?(payload)
               payload.fetch(:cached, false)
             end
@@ -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,14 @@ 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
+
+          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
@@ -78,6 +86,13 @@ module NewRelic
         def active_record_config(payload)
           return unless payload[:connection_id]
 
+          # handle if the notification payload provides the AR connection
+          # available in Rails 6+ & our ActiveRecordNotifications#log extension
+          if payload[:connection]
+            connection_config = payload[:connection].instance_variable_get(:@config)
+            return connection_config if connection_config
+          end
+
           connection = nil
           connection_id = payload[:connection_id]
 
@@ -92,58 +107,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
-
-          # Events do not always finish in the order they are started for this subscriber.
-          # The traced_method_stack expects that frames are popped off in the order that they
-          # are pushed, otherwise it will continue to pop up the stack until it finds the frame
-          # it expects. This will be fixed when we replace the tracer internals, but for now
-          # we need to work around this limitation.
-          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 = NewRelic::Agent::Transaction::DatastoreSegment.new product, operation, collection, host, port_path_or_id, database
-            if txn = state.current_transaction
-              segment.transaction = txn
-            end
-            segment._notice_sql sql, @config, @explainer, payload[:binds], payload[:name]
-            segment.start
-            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
 
-          # See comment for start_segment as we continue to work around limitations of the
-          # current tracer in this method.
-          def finish
-            if txn = state.current_transaction
-              txn.add_segment @segment
-            end
-            @segment.finish if @segment
-          end
-
-          def state
-            @state ||= NewRelic::Agent::TransactionState.tl_get
-          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 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.rb

@@ -0,0 +1,23 @@
+# 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_storage_subscriber'
+
+DependencyDetection.defer do
+  named :active_storage
+
+  depends_on do
+    defined?(::ActiveStorage) &&
+      !NewRelic::Agent::Instrumentation::ActiveStorageSubscriber.subscribed?
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing ActiveStorage 5 instrumentation'
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\.active_storage$/,
+      NewRelic::Agent::Instrumentation::ActiveStorageSubscriber.new)
+  end
+end

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

@@ -0,0 +1,63 @@
+# 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/notifications_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActiveStorageSubscriber < 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)
+          segment.params[:key] = payload[:key]
+          segment.params[:exist] = payload[:exist] if payload.key? :exist
+          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
+          service = payload[:service]
+          method = method_from_name name
+          "Ruby/ActiveStorage/#{service}Service/#{method}"
+        end
+
+        PATTERN = /\Aservice_([^\.]*)\.active_storage\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/acts_as_solr.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/database'
 
@@ -8,15 +8,31 @@ module NewRelic
   module Instrumentation
     module ActsAsSolrInstrumentation
       module ParserMethodsInstrumentation
-        def parse_query_with_newrelic(*args)
-          self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
-            begin
-              parse_query_without_newrelic(*args)
-            ensure
-              return unless txn = ::NewRelic::Agent::TransactionState.tl_get.current_transaction
-              txn.current_segment.params[:statement] = ::NewRelic::Agent::Database.truncate_query(args.first.inspect) rescue nil
+
+        if RUBY_VERSION < "2.7.0"
+          def parse_query_with_newrelic(*args)
+            self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
+              begin
+                parse_query_without_newrelic(*args)
+              ensure
+                return unless txn = ::NewRelic::Agent::Tracer.current_transaction
+                txn.current_segment.params[:statement] = ::NewRelic::Agent::Database.truncate_query(args.first.inspect) rescue nil
+              end
+            end
+          end
+  
+        else
+          def parse_query_with_newrelic(*args, **kwargs)
+            self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
+              begin
+                parse_query_without_newrelic(*args, **kwargs)
+              ensure
+                return unless txn = ::NewRelic::Agent::Tracer.current_transaction
+                txn.current_segment.params[:statement] = ::NewRelic::Agent::Database.truncate_query(args.first.inspect) rescue nil
+              end
             end
           end
+  
         end
       end
     end