newrelic_rpm 6.3.0.355 → 9.2.0

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

@@ -0,0 +1,48 @@
+# 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
+
+        def invoke_job_with_tracing
+          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/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_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,61 +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)
-            }
+    NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_delayed_job_version,
+      deprecation_msg
+    )
+  end
 
-            perform_action_with_newrelic_trace(options) do
-              invoke_job_without_new_relic(*args, &block)
-            end
-          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

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

@@ -0,0 +1,67 @@
+# 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 '../../datastores/nosql_obfuscator'
+
+module NewRelic::Agent::Instrumentation
+  module Elasticsearch
+    PRODUCT_NAME = 'Elasticsearch'
+    OPERATION = 'perform_request'
+
+    def perform_request_with_tracing(method, path, params = {}, body = nil, headers = nil)
+      return yield unless NewRelic::Agent::Tracer.tracing_enabled?
+
+      segment = NewRelic::Agent::Tracer.start_datastore_segment(
+        product: PRODUCT_NAME,
+        operation: nr_operation || OPERATION,
+        host: nr_hosts[:host],
+        port_path_or_id: path,
+        database_name: nr_cluster_name
+      )
+      begin
+        NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+      ensure
+        if segment
+          segment.notice_nosql_statement(nr_reported_query(body || params))
+          segment.finish
+        end
+      end
+    end
+
+    private
+
+    def nr_operation
+      operation_index = caller_locations.index do |line|
+        string = line.to_s
+        string.include?('lib/elasticsearch/api') && !string.include?(OPERATION)
+      end
+      return nil unless operation_index
+
+      caller_locations[operation_index].to_s.split('`')[-1].gsub(/\W/, '')
+    end
+
+    def nr_reported_query(query)
+      return unless NewRelic::Agent.config[:'elasticsearch.capture_queries']
+      return query unless NewRelic::Agent.config[:'elasticsearch.obfuscate_queries']
+
+      NewRelic::Agent::Datastores::NosqlObfuscator.obfuscate_statement(query)
+    end
+
+    def nr_cluster_name
+      return @nr_cluster_name if @nr_cluster_name
+      return if nr_hosts.empty?
+
+      NewRelic::Agent.disable_all_tracing do
+        @nr_cluster_name ||= perform_request('GET', '_cluster/health').body['cluster_name']
+      end
+    rescue StandardError => e
+      NewRelic::Agent.logger.error('Failed to get cluster name for elasticsearch', e)
+      nil
+    end
+
+    def nr_hosts
+      @nr_hosts ||= (transport.hosts.first || NewRelic::EMPTY_HASH)
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# 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::Prepend
+    include NewRelic::Agent::Instrumentation::Elasticsearch
+
+    def perform_request(*args)
+      perform_request_with_tracing(*args) { super }
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# 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 'elasticsearch/instrumentation'
+require_relative 'elasticsearch/chain'
+require_relative 'elasticsearch/prepend'
+
+DependencyDetection.defer do
+  named :elasticsearch
+
+  depends_on do
+    defined?(Elasticsearch)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing Elasticsearch instrumentation')
+
+    to_instrument = if Gem::Version.create(Elasticsearch::VERSION) < Gem::Version.create('8.0.0')
+      Elasticsearch::Transport::Client
+    else
+      Elastic::Transport::Client
+    end
+
+    if use_prepend?
+      prepend_instrument to_instrument, NewRelic::Agent::Instrumentation::Elasticsearch::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Elasticsearch::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/excon/middleware.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
 
 module ::Excon
   module Middleware
@@ -11,7 +11,7 @@ module ::Excon
         @stack = stack
       end
 
-      def request_call(datum) #THREAD_LOCAL_ACCESS
+      def request_call(datum) # THREAD_LOCAL_ACCESS
         begin
           # Only instrument this request if we haven't already done so, because
           # we can get request_call multiple times for requests marked as
@@ -25,7 +25,7 @@ module ::Excon
               procedure: wrapped_request.method
             )
 
-            segment.add_request_headers wrapped_request
+            segment.add_request_headers(wrapped_request)
 
             datum[:connection].instance_variable_set(TRACE_DATA_IVAR, segment)
           end
@@ -45,18 +45,20 @@ module ::Excon
         @stack.error_call(datum)
       end
 
-      def finish_trace(datum) #THREAD_LOCAL_ACCESS
-        segment = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+      def finish_trace(datum) # THREAD_LOCAL_ACCESS
+        # The following line needs else branch coverage
+        segment = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR) # rubocop:disable Style/SafeNavigation
         if segment
           begin
+            segment.notice_error(datum[:error]) if datum[:error]
             datum[:connection].instance_variable_set(TRACE_DATA_IVAR, nil)
 
             if datum[:response]
               wrapped_response = ::NewRelic::Agent::HTTPClients::ExconHTTPResponse.new(datum[:response])
-              segment.read_response_headers wrapped_response
+              segment.process_response_headers(wrapped_response)
             end
           ensure
-            segment.finish if segment
+            ::NewRelic::Agent::Transaction::Segment.finish(segment)
           end
         end
       end

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

@@ -1,21 +1,13 @@
-# 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
   named :excon
 
-  # We have two ways of instrumenting Excon:
-  # - For newer versions, use the middleware mechanism Excon exposes
-  # - For older versions, monkey-patch Excon::Connection#request
+  # We instrument Excon 0.19.0 and above using the middleware mechanism
   #
   # EXCON_MIN_VERSION is the minimum version we attempt to instrument at all.
-  # EXCON_MIDDLEWARE_MIN_VERSION is the min version we use the newer
-  #   instrumentation for.
-  #
-  # Note that middlewares were added to Excon prior to 0.19, but we don't
-  # use middleware-based instrumentation prior to that version because it didn't
-  # expose a way for middlewares to know about request failures.
   #
   # Why don't we use Excon.defaults[:instrumentor]?
   # While this might seem a perfect fit, it unfortunately isn't suitable in
@@ -25,48 +17,54 @@ DependencyDetection.defer do
   # so we could safely subscribe and not be clobbered by future subscribers,
   # but alas, it does not yet.
 
-  EXCON_MIN_VERSION = Gem::Version.new("0.10.1")
-  EXCON_MIDDLEWARE_MIN_VERSION = Gem::Version.new("0.19.0")
+  # TODO: MAJOR VERSION - update min version to 0.56.0
+  EXCON_MIN_VERSION = Gem::Version.new('0.19.0')
 
   depends_on do
-    defined?(::Excon) && defined?(::Excon::VERSION)
+    defined?(Excon) && defined?(Excon::VERSION)
   end
 
   executes do
-    excon_version = Gem::Version.new(::Excon::VERSION)
+    excon_version = Gem::Version.new(Excon::VERSION)
     if excon_version >= EXCON_MIN_VERSION
       install_excon_instrumentation(excon_version)
     else
-      ::NewRelic::Agent.logger.warn("Excon instrumentation requires at least version #{EXCON_MIN_VERSION}")
+      NewRelic::Agent.logger.warn("Excon instrumentation requires at least version #{EXCON_MIN_VERSION}")
     end
   end
 
+  executes do
+    next unless Gem::Version.new(Excon::VERSION) < Gem::Version.new('0.56.0')
+
+    deprecation_msg = 'Instrumentation for Excon versions below 0.56.0 is deprecated.' \
+      'They will stop being monitored in version 9.0.0. ' \
+      'Please upgrade your Excon version to continue receiving full support. '
+
+    NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_excon_version,
+      deprecation_msg
+    )
+
+    NewRelic::Agent.record_metric('Supportability/Deprecated/Excon', 1)
+  end
+
   def install_excon_instrumentation(excon_version)
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/excon_wrappers'
 
-    if excon_version >= EXCON_MIDDLEWARE_MIN_VERSION
-      install_middleware_excon_instrumentation
-    else
-      install_legacy_excon_instrumentation
-    end
+    install_middleware_excon_instrumentation
   end
 
   def install_middleware_excon_instrumentation
-    ::NewRelic::Agent.logger.info 'Installing middleware-based Excon instrumentation'
+    NewRelic::Agent.logger.info('Installing middleware-based Excon instrumentation')
     require 'new_relic/agent/instrumentation/excon/middleware'
     defaults = Excon.defaults
 
     if defaults[:middlewares]
-      defaults[:middlewares] << ::Excon::Middleware::NewRelicCrossAppTracing
+      defaults[:middlewares] << Excon::Middleware::NewRelicCrossAppTracing
     else
-      ::NewRelic::Agent.logger.warn("Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation")
+      NewRelic::Agent.logger.warn('Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation')
     end
   end
-
-  def install_legacy_excon_instrumentation
-    ::NewRelic::Agent.logger.info 'Installing legacy Excon instrumentation'
-    require 'new_relic/agent/instrumentation/excon/connection'
-    ::Excon::Connection.install_newrelic_instrumentation
-  end
 end

data/lib/new_relic/agent/instrumentation/fiber/chain.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::Agent::Instrumentation
+  module MonitoredFiber::Chain
+    def self.instrument!
+      ::Fiber.class_eval do
+        include NewRelic::Agent::Instrumentation::MonitoredFiber
+
+        alias_method(:initialize_without_new_relic, :initialize)
+
+        def initialize(*args, &block)
+          traced_block = add_thread_tracing(*args, &block)
+          initialize_with_newrelic_tracing { initialize_without_new_relic(*args, &traced_block) }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/fiber/instrumentation.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
+
+module NewRelic::Agent::Instrumentation
+  module MonitoredFiber
+    attr_reader :nr_parent_key
+
+    def initialize_with_newrelic_tracing
+      @nr_parent_key = NewRelic::Agent::Tracer.current_segment_key
+      yield
+    end
+
+    def add_thread_tracing(*args, &block)
+      return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
+
+      NewRelic::Agent::Tracer.thread_block_with_current_transaction(
+        *args,
+        segment_name: 'Ruby/Fiber',
+        &block
+      )
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# 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 MonitoredFiber
+    module Prepend
+      include NewRelic::Agent::Instrumentation::MonitoredFiber
+
+      def initialize(*args, &block)
+        traced_block = add_thread_tracing(*args, &block)
+        initialize_with_newrelic_tracing { super(*args, &traced_block) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# 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 'fiber/instrumentation'
+require_relative 'fiber/chain'
+require_relative 'fiber/prepend'
+
+DependencyDetection.defer do
+  named :fiber
+
+  depends_on do
+    defined?(Fiber)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing Fiber instrumentation')
+
+    if use_prepend?
+      prepend_instrument Fiber, NewRelic::Agent::Instrumentation::MonitoredFiber::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::MonitoredFiber::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/grape/chain.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
+
+module NewRelic::Agent::Instrumentation
+  module Grape
+    module Chain
+      def self.instrument!
+        Grape::Instrumentation.instrumented_class.class_eval do
+          def call_with_new_relic(env)
+            begin
+              call_without_new_relic(env)
+            ensure
+              Grape::Instrumentation.capture_transaction(env, self)
+            end
+          end
+
+          alias_method(:call_without_new_relic, :call)
+          alias_method(:call, :call_with_new_relic)
+        end
+      end
+    end
+  end
+end