newrelic_rpm 6.3.0.355 → 9.2.0

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

@@ -1,8 +1,9 @@
-# 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_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 +11,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 +32,8 @@ module NewRelic
           # we don't expect this to be called more than once, but we're being
           # defensive.
           return if defined?(cached?)
-          if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::STRING >= "5.1.0"
+
+          if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::STRING >= '5.1.0'
             def cached?(payload)
               payload.fetch(:cached, false)
             end
@@ -42,21 +44,27 @@ module NewRelic
           end
         end
 
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+        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
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+        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
@@ -64,20 +72,19 @@ module NewRelic
         def get_explain_plan(statement)
           connection = NewRelic::Agent::Database.get_connection(statement.config) do
             ::ActiveRecord::Base.send("#{statement.config[:adapter]}_connection",
-                                      statement.config)
+              statement.config)
           end
-          if connection && connection.respond_to?(:exec_query)
+          # the following line needs else branch coverage
+          if connection && connection.respond_to?(:exec_query) # rubocop:disable Style/SafeNavigation
             return connection.exec_query("EXPLAIN #{statement.sql}",
-                                         "Explain #{statement.name}",
-                                         statement.binds)
+              "Explain #{statement.name}",
+              statement.binds)
           end
         rescue => e
-          NewRelic::Agent.logger.debug "Couldn't fetch the explain plan for #{statement} due to #{e}"
+          NewRelic::Agent.logger.debug("Couldn't fetch the explain plan for #{statement} due to #{e}")
         end
 
         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]
@@ -85,64 +92,56 @@ module NewRelic
             return connection_config if connection_config
           end
 
-          connection = nil
-          connection_id = payload[:connection_id]
+          return unless connection_id = payload[:connection_id]
 
           ::ActiveRecord::Base.connection_handler.connection_pool_list.each do |handler|
-            connection = handler.connections.detect do |conn|
-              conn.object_id == connection_id
-            end
-
-            break if connection
+            connection = handler.connections.detect { |conn| conn.object_id == connection_id }
+            return connection.instance_variable_get(:@config) if connection
+
+            # when using makara, handler.connections will be empty, so use the
+            # spec config instead.
+            # https://github.com/newrelic/newrelic-ruby-agent/issues/507
+            # thank you @lucasklaassen
+            return handler.spec.config if use_spec_config?(handler)
           end
 
-          connection.instance_variable_get(:@config) if connection
+          nil
         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
-
-          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 = Tracer.start_datastore_segment product: product,
-                                                          operation: operation,
-                                                          collection: collection,
-                                                          host: host,
-                                                          port_path_or_id: port_path_or_id,
-                                                          database_name: database
+        def use_spec_config?(handler)
+          handler.respond_to?(:spec) &&
+            handler.spec &&
+            handler.spec.config &&
+            handler.spec.config[:adapter].end_with?('makara')
+        end
 
-            segment._notice_sql sql, @config, @explainer, payload[:binds], payload[:name]
-            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
 
-          def finish
-            @segment.finish if @segment
-          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 state
-            @state ||= NewRelic::Agent::Tracer.state
-          end
-
-          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

@@ -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
 
 require 'new_relic/agent/instrumentation/active_storage_subscriber'
 
@@ -8,12 +8,16 @@ DependencyDetection.defer do
   named :active_storage
 
   depends_on do
-    defined?(::ActiveStorage) &&
+    !NewRelic::Agent.config[:disable_active_storage]
+  end
+
+  depends_on do
+    defined?(ActiveStorage) &&
       !NewRelic::Agent::Instrumentation::ActiveStorageSubscriber.subscribed?
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveStorage 5 instrumentation'
+    NewRelic::Agent.logger.info('Installing ActiveStorage instrumentation')
   end
 
   executes do

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

@@ -1,56 +1,35 @@
-# 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'
 
 module NewRelic
   module Agent
     module Instrumentation
-      class ActiveStorageSubscriber < EventedSubscriber
-        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
-        rescue => e
-          log_notification_error e, name, 'finish'
-        end
-
-        def start_segment name, id, payload
-          segment = Tracer.start_segment name: metric_name(name, payload)
+      class ActiveStorageSubscriber < NotificationsSubscriber
+        def add_segment_params(segment, payload)
           segment.params[:key] = payload[:key]
-          segment.params[:exist] = payload[:exist] if payload.key? :exist
-          event_stack[id].push segment
-        end
-
-        def finish_segment id
-          segment = event_stack[id].pop
-          segment.finish if segment
+          segment.params[:exist] = payload[:exist] if payload.key?(:exist)
         end
 
-        def metric_name name, payload
+        def metric_name(name, payload)
           service = payload[:service]
-          method = method_from_name name
+          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
+            h[k] = NewRelic::UNKNOWN
           end
         end
 
-        def method_from_name name
+        def method_from_name(name)
           METHOD_NAME_MAPPING[name]
         end
       end

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

@@ -0,0 +1,27 @@
+# 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/active_support_subscriber'
+
+DependencyDetection.defer do
+  named :active_support
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_active_support]
+  end
+
+  depends_on do
+    defined?(ActiveSupport) &&
+      !NewRelic::Agent::Instrumentation::ActiveSupportSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActiveSupport instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\.active_support$/,
+      NewRelic::Agent::Instrumentation::ActiveSupportSubscriber.new)
+  end
+end

data/lib/new_relic/agent/instrumentation/active_support_logger/chain.rb

@@ -0,0 +1,23 @@
+# 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
+
+module NewRelic::Agent::Instrumentation
+  module ActiveSupportLogger
+    module Chain
+      def instrument!
+        ::ActiveSupport::Logger.module_eval do
+          include NewRelic::Agent::Instrumentation::ActiveSupportLogger
+          def broadcast_with_new_relic(logger)
+            broadcast_with_tracing(logger) {
+              broadcast_without_newrelic(logger)
+            }
+          end
+
+          alias broadcast_without_newrelic broadcast
+          alias broadcast broadcast_with_new_relic
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveSupportLogger
+        # Mark @skip_instrumenting on any broadcasted loggers to instrument Rails.logger only
+        def broadcast_with_tracing(logger)
+          NewRelic::Agent::Instrumentation::Logger.mark_skip_instrumenting(logger)
+          yield
+        rescue => error
+          NewRelic::Agent.notice_error(error)
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/active_support_logger/prepend.rb

@@ -0,0 +1,12 @@
+# 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
+
+module NewRelic::Agent::Instrumentation
+  module ActiveSupportLogger::Prepend
+    include NewRelic::Agent::Instrumentation::ActiveSupportLogger
+    def broadcast(logger)
+      broadcast_with_tracing(logger) { super }
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# 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_relative 'active_support_logger/instrumentation'
+require_relative 'active_support_logger/chain'
+require_relative 'active_support_logger/prepend'
+
+DependencyDetection.defer do
+  named :active_support_logger
+
+  depends_on { defined?(ActiveSupport::Logger) }
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActiveSupport::Logger instrumentation')
+
+    if use_prepend?
+      # the only method currently instrumented is a class method
+      prepend_instrument ActiveSupport::Logger.singleton_class, NewRelic::Agent::Instrumentation::ActiveSupportLogger::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::ActiveSupportLogger::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/active_support_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 ActiveSupportSubscriber < NotificationsSubscriber
+        def add_segment_params(segment, payload)
+          segment.params[:key] = payload[:key]
+          segment.params[:store] = payload[:store]
+          segment.params[:hit] = payload[:hit] if payload.key?(:hit)
+          segment.params[:super_operation] = payload[:super_operation] if payload.key?(:super_operation)
+          segment
+        end
+
+        def metric_name(name, payload)
+          store = payload[:store]
+          method = method_from_name(name)
+          "Ruby/ActiveSupport#{"/#{store}" if store}/#{method}"
+        end
+
+        PATTERN = /\Acache_([^\.]*)\.active_support\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/bunny/chain.rb

@@ -0,0 +1,45 @@
+# 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
+
+module NewRelic::Agent::Instrumentation
+  module Bunny::Chain
+    def self.instrument!
+      ::Bunny::Exchange.class_eval do
+        include NewRelic::Agent::Instrumentation::Bunny::Exchange
+
+        alias_method(:publish_without_new_relic, :publish)
+
+        def publish(payload, opts = {})
+          publish_with_tracing(payload, opts) { publish_without_new_relic(payload, opts) }
+        end
+      end
+
+      ::Bunny::Queue.class_eval do
+        include NewRelic::Agent::Instrumentation::Bunny::Queue
+
+        alias_method(:pop_without_new_relic, :pop)
+
+        def pop(opts = {:manual_ack => false}, &block)
+          pop_with_tracing { pop_without_new_relic(opts, &block) }
+        end
+
+        alias_method(:purge_without_new_relic, :purge)
+
+        def purge(*args)
+          purge_with_tracing { purge_without_new_relic(*args) }
+        end
+      end
+
+      ::Bunny::Consumer.class_eval do
+        include NewRelic::Agent::Instrumentation::Bunny::Consumer
+
+        alias_method(:call_without_new_relic, :call)
+
+        def call(*args)
+          call_with_tracing(*args) { call_without_new_relic(*args) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+# 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
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Bunny
+        module_function
+
+        LIBRARY = 'RabbitMQ'
+        DEFAULT_NAME = 'Default'
+        DEFAULT_TYPE = :direct
+        SLASH = '/'
+
+        def exchange_name(name)
+          name.empty? ? DEFAULT_NAME : name
+        end
+
+        def exchange_type(delivery_info, channel)
+          if di_exchange = delivery_info[:exchange]
+            return DEFAULT_TYPE if di_exchange.empty?
+            return channel.exchanges[delivery_info[:exchange]].type if channel.exchanges[di_exchange]
+          end
+        end
+
+        module Exchange
+          include Bunny
+
+          def publish_with_tracing(payload, opts = {})
+            begin
+              destination = exchange_name(name)
+
+              tracing_enabled =
+                NewRelic::Agent::CrossAppTracing.cross_app_enabled? ||
+                NewRelic::Agent.config[:'distributed_tracing.enabled']
+              opts[:headers] ||= {} if tracing_enabled
+
+              segment = NewRelic::Agent::Messaging.start_amqp_publish_segment(
+                library: LIBRARY,
+                destination_name: destination,
+                headers: opts[:headers],
+                routing_key: opts[:routing_key] || opts[:key],
+                reply_to: opts[:reply_to],
+                correlation_id: opts[:correlation_id],
+                exchange_type: type
+              )
+            rescue => e
+              NewRelic::Agent.logger.error('Error starting message broker segment in Bunny::Exchange#publish', e)
+              yield
+            else
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                yield
+              end
+            ensure
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
+            end
+          end
+        end
+
+        module Queue
+          include Bunny
+
+          def pop_with_tracing
+            bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
+            begin
+              t0 = Process.clock_gettime(Process::CLOCK_REALTIME)
+              msg = yield
+              delivery_info, message_properties, _payload = msg
+            rescue StandardError => error
+              bunny_error = error
+            end
+
+            begin
+              exch_name, exch_type = if delivery_info
+                [exchange_name(delivery_info.exchange),
+                  exchange_type(delivery_info, channel)]
+              else
+                [exchange_name(NewRelic::EMPTY_STR),
+                  exchange_type({}, channel)]
+              end
+
+              segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
+                library: LIBRARY,
+                destination_name: exch_name,
+                delivery_info: (delivery_info || {}),
+                message_properties: (message_properties || {headers: {}}),
+                exchange_type: exch_type,
+                queue_name: name,
+                start_time: t0
+              )
+            rescue => e
+              NewRelic::Agent.logger.error('Error starting message broker segment in Bunny::Queue#pop', e)
+            else
+              if bunny_error
+                segment.notice_error(bunny_error)
+                raise bunny_error
+              end
+            ensure
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
+            end
+
+            msg
+          end
+
+          def purge_with_tracing
+            begin
+              type = server_named? ? :temporary_queue : :queue
+              segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+                action: :purge,
+                library: LIBRARY,
+                destination_type: type,
+                destination_name: name
+              )
+            rescue => e
+              NewRelic::Agent.logger.error('Error starting message broker segment in Bunny::Queue#purge', e)
+              yield
+            else
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                yield
+              end
+            ensure
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
+            end
+          end
+        end
+
+        module Consumer
+          include Bunny
+
+          def call_with_tracing(*args)
+            delivery_info, message_properties, _ = args
+            queue_name = queue.respond_to?(:name) ? queue.name : queue
+
+            NewRelic::Agent::Messaging.wrap_amqp_consume_transaction(
+              library: LIBRARY,
+              destination_name: exchange_name(delivery_info.exchange),
+              delivery_info: delivery_info,
+              message_properties: message_properties,
+              exchange_type: exchange_type(delivery_info, channel),
+              queue_name: queue_name
+            ) do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/bunny/prepend.rb

@@ -0,0 +1,35 @@
+# 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
+
+module NewRelic::Agent::Instrumentation
+  module Bunny::Prepend
+    module Exchange
+      include NewRelic::Agent::Instrumentation::Bunny::Exchange
+
+      def publish(payload, opts = {})
+        publish_with_tracing(payload, opts) { super }
+      end
+    end
+
+    module Queue
+      include NewRelic::Agent::Instrumentation::Bunny::Queue
+
+      def pop(opts = {:manual_ack => false}, &block)
+        pop_with_tracing { super }
+      end
+
+      def purge(*args)
+        purge_with_tracing { super }
+      end
+    end
+
+    module Consumer
+      include NewRelic::Agent::Instrumentation::Bunny::Consumer
+
+      def call(*args)
+        call_with_tracing(*args) { super }
+      end
+    end
+  end
+end