newrelic_rpm 6.15.0 → 9.7.1

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

@@ -0,0 +1,61 @@
+# 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 'instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Curb
+        module Easy
+          module Prepend
+            include NewRelic::Agent::Instrumentation::Curb::Easy
+
+            def http_head(*args, &blk)
+              http_head_with_tracing { super }
+            end
+
+            def http_post(*args, &blk)
+              http_post_with_tracing { super }
+            end
+
+            def http_put(*args, &blk)
+              http_put_with_tracing { super }
+            end
+
+            def http(verb)
+              http_with_tracing(verb) { super }
+            end
+
+            def perform
+              perform_with_tracing { super }
+            end
+
+            def method(verb)
+              method_with_tracing(verb) { super }
+            end
+
+            def header_str
+              header_str_with_tracing { super }
+            end
+          end
+        end
+
+        module Multi
+          module Prepend
+            include NewRelic::Agent::Instrumentation::Curb::Multi
+
+            def add(curl)
+              add_with_tracing(curl) { super }
+            end
+
+            def perform(&blk)
+              perform_with_tracing { super }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,264 +1,32 @@
-# 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_relative 'curb/chain'
+require_relative 'curb/prepend'
 
 DependencyDetection.defer do
   named :curb
 
-  CURB_MIN_VERSION = Gem::Version.new("0.8.1")
+  CURB_MIN_VERSION = Gem::Version.new('0.8.1')
 
   depends_on do
-    defined?(::Curl) && defined?(::Curl::CURB_VERSION) &&
-      Gem::Version.new(::Curl::CURB_VERSION) >= CURB_MIN_VERSION
+    defined?(Curl) && defined?(Curl::CURB_VERSION) &&
+      Gem::Version.new(Curl::CURB_VERSION) >= CURB_MIN_VERSION
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Curb instrumentation'
+    NewRelic::Agent.logger.info('Installing Curb instrumentation')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/curb_wrappers'
   end
 
   executes do
-    class Curl::Easy
-
-      attr_accessor :_nr_instrumented,
-                    :_nr_failure_instrumented,
-                    :_nr_http_verb,
-                    :_nr_header_str,
-                    :_nr_original_on_header,
-                    :_nr_original_on_complete,
-                    :_nr_original_on_failure,
-                    :_nr_serial
-
-      # We have to hook these three methods separately, as they don't use
-      # Curl::Easy#http
-      def http_head_with_newrelic(*args, &blk)
-        self._nr_http_verb = :HEAD
-        http_head_without_newrelic(*args, &blk)
-      end
-
-
-      alias_method :http_head_without_newrelic, :http_head
-      alias_method :http_head, :http_head_with_newrelic
-
-      def http_post_with_newrelic(*args, &blk)
-        self._nr_http_verb = :POST
-        http_post_without_newrelic(*args, &blk)
-      end
-
-
-      alias_method :http_post_without_newrelic, :http_post
-      alias_method :http_post, :http_post_with_newrelic
-
-      def http_put_with_newrelic(*args, &blk)
-        self._nr_http_verb = :PUT
-        http_put_without_newrelic(*args, &blk)
-      end
-
-
-      alias_method :http_put_without_newrelic, :http_put
-      alias_method :http_put, :http_put_with_newrelic
-
-
-      # Hook the #http method to set the verb.
-      def http_with_newrelic verb
-        self._nr_http_verb = verb.to_s.upcase
-        http_without_newrelic( verb )
-      end
-
-      alias_method :http_without_newrelic, :http
-      alias_method :http, :http_with_newrelic
-
-      # Hook the #perform method to mark the request as non-parallel.
-      def perform_with_newrelic
-        self._nr_http_verb ||= :GET
-        self._nr_serial = true
-        perform_without_newrelic
-      end
-
-      alias_method :perform_without_newrelic, :perform
-      alias_method :perform, :perform_with_newrelic
-
-      # Record the HTTP verb for future #perform calls
-      def method_with_newrelic verb
-        self._nr_http_verb = verb.upcase
-        method_without_newrelic(verb)
-      end
-
-      alias_method :method_without_newrelic, :method
-      alias_method :method, :method_with_newrelic
-
-      # We override this method in order to ensure access to header_str even
-      # though we use an on_header callback
-      def header_str_with_newrelic
-        if self._nr_serial
-          self._nr_header_str
-        else
-          # Since we didn't install a header callback for a non-serial request,
-          # just fall back to the original implementation.
-          header_str_without_newrelic
-        end
-      end
-
-      alias_method :header_str_without_newrelic, :header_str
-      alias_method :header_str, :header_str_with_newrelic
-    end # class Curl::Easy
-
-
-    class Curl::Multi
-      include NewRelic::Agent::MethodTracer
-
-      # Add CAT with callbacks if the request is serial
-      def add_with_newrelic(curl)
-        if curl.respond_to?(:_nr_serial) && curl._nr_serial
-          hook_pending_request(curl) if NewRelic::Agent::Tracer.tracing_enabled?
-        end
-
-        return add_without_newrelic curl
-      end
-
-      alias_method :add_without_newrelic, :add
-      alias_method :add, :add_with_newrelic
-
-      # Trace as an External/Multiple call if the first request isn't serial.
-      def perform_with_newrelic(&blk)
-        return perform_without_newrelic if first_request_is_serial?
-
-        trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
-          perform_without_newrelic(&blk)
-        end
-      end
-
-      alias_method :perform_without_newrelic, :perform
-      alias_method :perform, :perform_with_newrelic
-
-
-      # Instrument the specified +request+ (a Curl::Easy object)
-      # and set up cross-application tracing if it's enabled.
-      def hook_pending_request(request)
-        wrapped_request, wrapped_response = wrap_request(request)
-
-        segment = NewRelic::Agent::Tracer.start_external_request_segment(
-          library: wrapped_request.type,
-          uri: wrapped_request.uri,
-          procedure: wrapped_request.method
-        )
-
-        segment.add_request_headers wrapped_request
-
-        # install all callbacks
-        unless request._nr_instrumented
-          install_header_callback(request, wrapped_response)
-          install_completion_callback(request, wrapped_response, segment)
-          install_failure_callback(request, wrapped_response, segment)
-          request._nr_instrumented = true
-        end
-      rescue => err
-        NewRelic::Agent.logger.error("Untrapped exception", err)
-      end
-
-
-      # Create request and response adapter objects for the specified +request+
-      # NOTE: Although strange to wrap request and response at once, it works
-      # because curb's callback mechanism updates the instantiated wrappers
-      # during the life-cycle of external request
-      def wrap_request(request)
-        return NewRelic::Agent::HTTPClients::CurbRequest.new(request),
-               NewRelic::Agent::HTTPClients::CurbResponse.new(request)
-      end
-
-      # Install a callback that will record the response headers
-      # to enable CAT linking
-      def install_header_callback(request, wrapped_response)
-        original_callback = request.on_header
-        request._nr_original_on_header = original_callback
-        request._nr_header_str = nil
-        request.on_header do |header_data|
-          if original_callback
-            original_callback.call header_data
-          else
-            wrapped_response.append_header_data header_data
-            header_data.length
-          end
-        end
-      end
-
-      # Install a callback that will finish the trace.
-      def install_completion_callback(request, wrapped_response, segment)
-        original_callback = request.on_complete
-        request._nr_original_on_complete = original_callback
-        request.on_complete do |finished_request|
-          begin
-            segment.process_response_headers wrapped_response
-          ensure
-            segment.finish if segment
-            # Make sure the existing completion callback is run, and restore the
-            # on_complete callback to how it was before.
-            original_callback.call(finished_request) if original_callback
-            remove_instrumentation_callbacks(request)
-          end
-        end
-      end
-
-      # Install a callback that will fire on failures
-      # NOTE:  on_failure is not always called, so we're not always
-      # unhooking the callback.  No harm/no foul in production, but
-      # definitely something to beware of if debugging callback issues
-      # _nr_failure_instrumented exists to prevent infinitely chaining
-      # our on_failure callback hook.
-      def install_failure_callback(request, wrapped_response, segment)
-        return if request._nr_failure_instrumented
-        original_callback = request.on_failure
-        request._nr_original_on_failure = original_callback
-        request.on_failure do |failed_request, error|
-          begin
-            if segment
-              noticible_error = NewRelic::Agent::NoticibleError.new error[0].name, error[-1]
-              segment.notice_error noticible_error
-            end
-          ensure
-            original_callback.call(failed_request, error) if original_callback
-            remove_failure_callback(failed_request)
-          end
-          request._nr_failure_instrumented = true 
-        end
-      end
-
-      # on_failure callbacks cannot be removed in the on_complete
-      # callback where this method is invoked because on_complete
-      # fires before the on_failure!
-      def remove_instrumentation_callbacks(request)
-        request.on_complete(&request._nr_original_on_complete)
-        request.on_header(&request._nr_original_on_header)
-        request._nr_instrumented = false
-      end
-
-      # We execute customer's on_failure callback (if any) and 
-      # uninstall our hook here since the on_complete callback 
-      # fires before the on_failure callback.
-      def remove_failure_callback(request)
-        request.on_failure(&request._nr_original_on_failure)
-        request._nr_failure_instrumented = false
-      end
-
-      private
-
-      def first_request_is_serial?
-        return false unless (first = self.requests.first)
-
-        # Before curb 0.9.8, requests was an array of Curl::Easy
-        # instances.  Starting with 0.9.8, it's a Hash where the
-        # values are Curl::Easy instances.
-        #
-        # So, requests.first will either be an_obj or [a_key, an_obj].
-        # We need to handle either case.
-        #
-        first = first[-1] if first.is_a?(Array)
-
-        first.respond_to?(:_nr_serial) && first._nr_serial
-      end
-
-    end # class Curl::Multi
-
+    if use_prepend?
+      prepend_instrument Curl::Easy, NewRelic::Agent::Instrumentation::Curb::Easy::Prepend
+      prepend_instrument Curl::Multi, NewRelic::Agent::Instrumentation::Curb::Multi::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Curb::Chain
+    end
   end
 end

data/lib/new_relic/agent/instrumentation/custom_events.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
+
+# This is a helper file that will allow apps using ActiveSupport without Rails
+# to still leverage all ActiveSupport based instrumentation functionality
+# offered by the agent that would otherwise be gated by the detection of Rails.
+
+# ActiveSupport notifications custom events
+if !defined?(Rails) && defined?(ActiveSupport::Notifications) && defined?(ActiveSupport::IsolatedExecutionState)
+  require_relative 'rails_notifications/custom_events'
+end

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

@@ -0,0 +1,38 @@
+# 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 custom events
+module NewRelic::Agent::Instrumentation
+  class CustomEventsSubscriber < NotificationsSubscriber
+    def start(name, id, _payload) # THREAD_LOCAL_ACCESS
+      return unless state.is_execution_traced?
+
+      finishable = NewRelic::Agent::Tracer.start_transaction_or_segment(name: transaction_name(name),
+        category: :custom_events)
+      push_segment(id, finishable)
+    rescue => e
+      log_notification_error(e, name, 'start')
+    end
+
+    def finish(name, id, payload) # THREAD_LOCAL_ACCESS
+      return unless state.is_execution_traced?
+
+      NewRelic::Agent.notice_error(payload[:exception_object]) if payload.key?(:exception_object)
+
+      finishable = pop_segment(id)
+      # the following line needs else branch coverage
+      finishable.finish if finishable # rubocop:disable Style/SafeNavigation
+    rescue => e
+      log_notification_error(e, name, 'finish')
+    end
+
+    private
+
+    def transaction_name(name)
+      "ActiveSupport/CustomEvents/#{name}"
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# 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 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module DelayedJob
+    module Chain
+      def self.instrument!
+        Delayed::Worker.class_eval do
+          include NewRelic::Agent::Instrumentation::DelayedJob
+
+          def initialize_with_new_relic(*args)
+            initialize_with_tracing { initialize_without_new_relic(*args) }
+          end
+
+          alias initialize_without_new_relic initialize
+          alias initialize initialize_with_new_relic
+
+          def install_newrelic_job_tracer
+            Delayed::Job.class_eval do
+              include NewRelic::Agent::Instrumentation::DelayedJobTracer
+
+              alias_method(:invoke_job_without_new_relic, :invoke_job)
+
+              def invoke_job(*args, &block)
+                invoke_job_with_tracing { invoke_job_without_new_relic(*args, &block) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# 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 DelayedJob
+        def initialize_with_tracing
+          yield
+          worker_name = case
+                        when self.respond_to?(:name) then self.name
+                        when self.class.respond_to?(:default_name) then self.class.default_name
+          end
+          NewRelic::DelayedJobInjection.worker_name = worker_name
+
+          # TODO: Refactor the last line of this condition so that it can be evaluated in both prepend and chain instrumentation
+          if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
+              !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic))
+
+            ::NewRelic::Agent.logger.info('Installing DelayedJob instrumentation [part 2/2]')
+            install_newrelic_job_tracer
+            NewRelic::Control.instance.init_plugin(:dispatcher => :delayed_job)
+          else
+            NewRelic::Agent.logger.warn('Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation')
+          end
+        end
+      end
+
+      module DelayedJobTracer
+        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+        NR_TRANSACTION_CATEGORY = 'OtherTransaction/DelayedJob'.freeze
+        INSTRUMENTATION_NAME = 'DelayedJob'
+
+        def invoke_job_with_tracing
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+          options = {
+            :category => NR_TRANSACTION_CATEGORY,
+            :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)
+          }
+
+          perform_action_with_newrelic_trace(options) do
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/delayed_job/prepend.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_relative 'instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module DelayedJob
+        module Prepend
+          include NewRelic::Agent::Instrumentation::DelayedJob
+
+          def initialize(*args)
+            initialize_with_tracing { super }
+          end
+
+          def install_newrelic_job_tracer
+            Delayed::Job.send(:prepend, ::NewRelic::Agent::Instrumentation::DelayedJobTracerPrepend)
+          end
+        end
+      end
+
+      module DelayedJobTracerPrepend
+        include NewRelic::Agent::Instrumentation::DelayedJobTracer
+
+        def invoke_job(*args, &block)
+          invoke_job_with_tracing { super }
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,9 @@
-# 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_relative 'delayed_job/chain'
+require_relative 'delayed_job/prepend'
 
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -11,14 +14,14 @@ module NewRelic
         module Naming
           module_function
 
-          CLASS_METHOD_DELIMITER     = '.'.freeze
-          INSTANCE_METHOD_DELIMITER  = '#'.freeze
+          CLASS_METHOD_DELIMITER = '.'.freeze
+          INSTANCE_METHOD_DELIMITER = '#'.freeze
           LEGACY_DJ_FORMAT_DELIMITER = ';'.freeze
-          LEGACY_DJ_FORMAT_PREFIX    = 'LOAD'.freeze
-          LEGACY_DJ_DEFAULT_CLASS    = '(unknown class)'.freeze
+          LEGACY_DJ_FORMAT_PREFIX = 'LOAD'.freeze
+          LEGACY_DJ_DEFAULT_CLASS = '(unknown class)'.freeze
 
           def name_from_payload(payload_object)
-            if payload_object.is_a? ::Delayed::PerformableMethod
+            if payload_object.is_a?(::Delayed::PerformableMethod)
               # payload_object contains a reference to an object
               # that received an asynchronous method call via .delay or .handle_asynchronously
               "#{object_name(payload_object)}#{delimiter(payload_object)}#{method_name(payload_object)}"
@@ -76,63 +79,37 @@ DependencyDetection.defer do
   @name = :delayed_job
 
   depends_on do
-    !NewRelic::Agent.config[:disable_dj]
+    defined?(Delayed) && defined?(Delayed::Worker)
   end
 
-  depends_on do
-    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Agent.config[:disable_dj]
+  executes do
+    NewRelic::Agent.logger.info('Installing DelayedJob instrumentation [part 1/2]')
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 1/2]'
+    if use_prepend?
+      prepend_instrument Delayed::Worker, NewRelic::Agent::Instrumentation::DelayedJob::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::DelayedJob::Chain
+    end
   end
 
   executes do
-    Delayed::Worker.class_eval do
-
-      def initialize_with_new_relic(*args)
-        initialize_without_new_relic(*args)
-        worker_name = case
-                      when self.respond_to?(:name) then self.name
-                      when self.class.respond_to?(:default_name) then self.class.default_name
-                      end
-        NewRelic::DelayedJobInjection.worker_name = worker_name
-
-        if defined?(::Delayed::Job) && ::Delayed::Job.method_defined?(:invoke_job) &&
-          !(::Delayed::Job.method_defined?(:invoke_job_without_new_relic) )
-
-          ::NewRelic::Agent.logger.info 'Installing DelayedJob instrumentation [part 2/2]'
-          install_newrelic_job_tracer
-          NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job
-        else
-          NewRelic::Agent.logger.warn("Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation")
-        end
-      end
-
-      alias initialize_without_new_relic initialize
-      alias initialize initialize_with_new_relic
-
-      NR_TRANSACTION_CATEGORY = 'OtherTransaction/DelayedJob'.freeze
+    next unless delayed_job_version < Gem::Version.new('4.1.0')
 
-      def install_newrelic_job_tracer
-        Delayed::Job.class_eval do
-          include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    deprecation_msg = 'Instrumentation for DelayedJob versions below 4.1.0 is deprecated.' \
+      'It will stop being monitored in version 9.0.0. ' \
+      'Please upgrade your DelayedJob version to continue receiving full support. ' \
 
-          alias_method :invoke_job_without_new_relic, :invoke_job
-
-          def invoke_job(*args, &block)
-            options = {
-              :category => NR_TRANSACTION_CATEGORY,
-              :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)
-            }
-
-            perform_action_with_newrelic_trace(options) do
-              invoke_job_without_new_relic(*args, &block)
-            end
-          end
+    NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_delayed_job_version,
+      deprecation_msg
+    )
+  end
 
-        end
-      end
-    end
+  def delayed_job_version
+    # the following line needs else branch coverage
+    Gem.loaded_specs['delayed_job'].version if Gem.loaded_specs['delayed_job'] # rubocop:disable Style/SafeNavigation
   end
 end

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

@@ -0,0 +1,29 @@
+# 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 Elasticsearch::Chain
+    def self.instrument!
+      to_instrument = if ::Gem::Version.create(::Elasticsearch::VERSION) <
+          ::Gem::Version.create('8.0.0')
+        ::Elasticsearch::Transport::Client
+      else
+        ::Elastic::Transport::Client
+      end
+
+      to_instrument.class_eval do
+        include NewRelic::Agent::Instrumentation::Elasticsearch
+
+        alias_method(:perform_request_without_tracing, :perform_request)
+        alias_method(:perform_request, :perform_request_with_tracing)
+
+        def perform_request(*args)
+          perform_request_with_tracing(*args) do
+            perform_request_without_tracing(*args)
+          end
+        end
+      end
+    end
+  end
+end