newrelic_rpm 8.15.0 → 9.6.0

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

@@ -0,0 +1,69 @@
+# 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 ActiveSupportBroadcastLogger::Chain
+    def self.instrument!
+      ::ActiveSupportBroadcastLogger.class_eval do
+        include NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger
+
+        alias_method(:add_without_new_relic, :add)
+
+        def add(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            add_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:debug_without_new_relic, :debug)
+
+        def debug(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            debug_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:info_without_new_relic, :info)
+
+        def info(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            info_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:warn_without_new_relic, :warn)
+
+        def warn(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            warn_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:error_without_new_relic, :error)
+
+        def error(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            error_without_new_relic(*args, &traced_task)
+          end
+        end
+
+        alias_method(:fatal_without_new_relic, :fatal)
+
+        def fatal(*args, &task)
+          record_one_broadcast_with_new_relic(*args) do
+            fatal_without_new_relic(*args, &traced_task)
+          end
+        end
+      end
+
+      alias_method(:unknown_without_new_relic, :unknown)
+
+      def unknown(*args, &task)
+        record_one_broadcast_with_new_relic(*args) do
+          unknown_without_new_relic(*args, &traced_task)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/active_support_broadcast_logger/instrumentation.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 ActiveSupportBroadcastLogger
+    def record_one_broadcast_with_new_relic(*args)
+      broadcasts[1..-1].each { |broadcasted_logger| broadcasted_logger.instance_variable_set(:@skip_instrumenting, true) }
+      yield
+      broadcasts.each { |broadcasted_logger| broadcasted_logger.instance_variable_set(:@skip_instrumenting, false) }
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# 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 ActiveSupportBroadcastLogger::Prepend
+    include NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger
+
+    def add(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def debug(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def info(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def warn(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def error(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def fatal(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+
+    def unknown(*args)
+      record_one_broadcast_with_new_relic(*args) { super }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/active_support_broadcast_logger.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
+
+require_relative 'active_support_broadcast_logger/instrumentation'
+require_relative 'active_support_broadcast_logger/chain'
+require_relative 'active_support_broadcast_logger/prepend'
+
+DependencyDetection.defer do
+  named :'active_support_broadcast_logger'
+
+  depends_on { defined?(ActiveSupport::BroadcastLogger) }
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ActiveSupport::BroadcastLogger instrumentation')
+
+    if use_prepend?
+      prepend_instrument ActiveSupport::BroadcastLogger, NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::ActiveSupportBroadcastLogger::Chain
+    end
+  end
+end

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

@@ -6,8 +6,12 @@ module NewRelic
   module Agent
     module Instrumentation
       module ActiveSupportLogger
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
         # Mark @skip_instrumenting on any broadcasted loggers to instrument Rails.logger only
         def broadcast_with_tracing(logger)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           NewRelic::Agent::Instrumentation::Logger.mark_skip_instrumenting(logger)
           yield
         rescue => error

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

@@ -9,7 +9,9 @@ require_relative 'active_support_logger/prepend'
 DependencyDetection.defer do
   named :active_support_logger
 
-  depends_on { defined?(ActiveSupport::Logger) }
+  depends_on do
+    defined?(ActiveSupport::Logger) && defined?(ActiveSupport::Logger.broadcast)
+  end
 
   executes do
     NewRelic::Agent.logger.info('Installing ActiveSupport::Logger instrumentation')

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/async_http/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
+
+require_relative 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module AsyncHttp::Chain
+    def self.instrument!
+      ::Async::HTTP::Internet.class_eval do
+        include NewRelic::Agent::Instrumentation::AsyncHttp
+
+        alias_method(:call_without_new_relic, :call)
+
+        def call(method, url, headers = nil, body = nil)
+          call_with_new_relic(method, url, headers, body) do |hdr|
+            call_without_new_relic(method, url, hdr, body)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# 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/http_clients/async_http_wrappers'
+
+module NewRelic::Agent::Instrumentation
+  module AsyncHttp
+    def call_with_new_relic(method, url, headers = nil, body = nil)
+      headers ||= {} # if it is nil, we need to make it a hash so we can insert headers
+      wrapped_request = NewRelic::Agent::HTTPClients::AsyncHTTPRequest.new(self, method, url, headers)
+
+      segment = NewRelic::Agent::Tracer.start_external_request_segment(
+        library: wrapped_request.type,
+        uri: wrapped_request.uri,
+        procedure: wrapped_request.method
+      )
+
+      begin
+        response = nil
+        segment.add_request_headers(wrapped_request)
+
+        NewRelic::Agent.disable_all_tracing do
+          response = NewRelic::Agent::Tracer.capture_segment_error(segment) do
+            yield(headers)
+          end
+        end
+
+        wrapped_response = NewRelic::Agent::HTTPClients::AsyncHTTPResponse.new(response)
+        segment.process_response_headers(wrapped_response)
+        response
+      ensure
+        segment&.finish
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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 AsyncHttp::Prepend
+    include NewRelic::Agent::Instrumentation::AsyncHttp
+
+    def call(method, url, headers = nil, body = nil)
+      call_with_new_relic(method, url, headers, body) { |hdr| super(method, url, hdr, body) }
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# 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 'async_http/instrumentation'
+require_relative 'async_http/chain'
+require_relative 'async_http/prepend'
+
+DependencyDetection.defer do
+  named :async_http
+
+  depends_on do
+    defined?(Async::HTTP) && Gem::Version.new(Async::HTTP::VERSION) >= Gem::Version.new('0.59.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing async_http instrumentation')
+
+    require 'async/http/internet'
+    if use_prepend?
+      prepend_instrument Async::HTTP::Internet, NewRelic::Agent::Instrumentation::AsyncHttp::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::AsyncHttp::Chain
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 # frozen_string_literal: true
 
 module NewRelic::Agent::Instrumentation
-  module Bunny
+  module Bunny::Chain
     def self.instrument!
       ::Bunny::Exchange.class_eval do
         include NewRelic::Agent::Instrumentation::Bunny::Exchange

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

@@ -12,6 +12,7 @@ module NewRelic
         DEFAULT_NAME = 'Default'
         DEFAULT_TYPE = :direct
         SLASH = '/'
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
         def exchange_name(name)
           name.empty? ? DEFAULT_NAME : name
@@ -28,6 +29,8 @@ module NewRelic
           include Bunny
 
           def publish_with_tracing(payload, opts = {})
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               destination = exchange_name(name)
 
@@ -46,7 +49,7 @@ module NewRelic
                 exchange_type: type
               )
             rescue => e
-              NewRelic::Agent.logger.error("Error starting message broker segment in Bunny::Exchange#publish", 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
@@ -62,6 +65,8 @@ module NewRelic
           include Bunny
 
           def pop_with_tracing
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
             begin
               t0 = Process.clock_gettime(Process::CLOCK_REALTIME)
@@ -90,7 +95,7 @@ module NewRelic
                 start_time: t0
               )
             rescue => e
-              NewRelic::Agent.logger.error("Error starting message broker segment in Bunny::Queue#pop", e)
+              NewRelic::Agent.logger.error('Error starting message broker segment in Bunny::Queue#pop', e)
             else
               if bunny_error
                 segment.notice_error(bunny_error)
@@ -104,6 +109,8 @@ module NewRelic
           end
 
           def purge_with_tracing
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               type = server_named? ? :temporary_queue : :queue
               segment = NewRelic::Agent::Tracer.start_message_broker_segment(
@@ -113,7 +120,7 @@ module NewRelic
                 destination_name: name
               )
             rescue => e
-              NewRelic::Agent.logger.error("Error starting message broker segment in Bunny::Queue#purge", 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
@@ -129,6 +136,8 @@ module NewRelic
           include Bunny
 
           def call_with_tracing(*args)
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             delivery_info, message_properties, _ = args
             queue_name = queue.respond_to?(:name) ? queue.name : queue
 

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

@@ -26,7 +26,7 @@ DependencyDetection.defer do
       prepend_instrument Bunny::Queue, NewRelic::Agent::Instrumentation::Bunny::Prepend::Queue
       prepend_instrument Bunny::Consumer, NewRelic::Agent::Instrumentation::Bunny::Prepend::Consumer
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Bunny
+      chain_instrument NewRelic::Agent::Instrumentation::Bunny::Chain
     end
   end
 end

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

@@ -13,7 +13,7 @@ module NewRelic::Agent::Instrumentation
         def post(*args, &task)
           return post_without_new_relic(*args, &task) unless NewRelic::Agent::Tracer.tracing_enabled?
 
-          traced_task = add_task_tracing(*args, &task)
+          traced_task = add_task_tracing(&task)
           post_without_new_relic(*args, &traced_task)
         end
       end

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

@@ -5,13 +5,12 @@
 module NewRelic::Agent::Instrumentation
   module ConcurrentRuby
     SEGMENT_NAME = 'Concurrent/Task'
-    SUPPORTABILITY_METRIC = 'Supportability/ConcurrentRuby/Invoked'
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
-    def add_task_tracing(*args, &task)
-      NewRelic::Agent.record_metric_once(SUPPORTABILITY_METRIC)
+    def add_task_tracing(&task)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
 
       NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-        *args,
         segment_name: SEGMENT_NAME,
         parent: NewRelic::Agent::Tracer.current_segment,
         &task

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

@@ -10,7 +10,7 @@ module NewRelic::Agent::Instrumentation
       def post(*args, &task)
         return super(*args, &task) unless NewRelic::Agent::Tracer.tracing_enabled?
 
-        traced_task = add_task_tracing(*args, &task)
+        traced_task = add_task_tracing(&task)
         super(*args, &traced_task)
       end
     end

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

@@ -41,8 +41,6 @@ module NewRelic
             clazz.extend(ClassMethodsShim)
           end
 
-          def new_relic_trace_controller_action(*args); yield; end
-
           def perform_action_with_newrelic_trace(*args); yield; end
         end
 
@@ -180,7 +178,7 @@ module NewRelic
             code_info = NewRelic::Agent::MethodTracerHelpers.code_information(self, method)
             argument_list = generate_argument_list(options.merge(code_info))
 
-            class_eval(<<-EOC)
+            class_eval(<<~EOC)
               def #{with_method_name}(*args, &block)
                 perform_action_with_newrelic_trace(#{argument_list.join(',')}) do
                   #{without_method_name}(*args, &block)
@@ -236,7 +234,8 @@ module NewRelic
           end
 
           def self.prefix_for_category(txn, category = nil)
-            category ||= (txn && txn.category)
+            # the following line needs else branch coverage
+            category ||= (txn && txn.category) # rubocop:disable Style/SafeNavigation
             case category
             when :controller then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
             when :web then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
@@ -244,6 +243,7 @@ module NewRelic
             when :background then ::NewRelic::Agent::Transaction::TASK_PREFIX
             when :rack then ::NewRelic::Agent::Transaction::RACK_PREFIX
             when :uri then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :roda then ::NewRelic::Agent::Transaction::RODA_PREFIX
             when :sinatra then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
             when :middleware then ::NewRelic::Agent::Transaction::MIDDLEWARE_PREFIX
             when :grape then ::NewRelic::Agent::Transaction::GRAPE_PREFIX
@@ -360,7 +360,7 @@ module NewRelic
           skip_tracing = do_not_trace? || !state.is_execution_traced?
 
           if skip_tracing
-            state.current_transaction.ignore! if state.current_transaction
+            state.current_transaction&.ignore!
             NewRelic::Agent.disable_all_tracing { return yield }
           end
 
@@ -386,7 +386,8 @@ module NewRelic
               raise
             end
           ensure
-            finishable.finish if finishable
+            # the following line needs else branch coverage
+            finishable.finish if finishable # rubocop:disable Style/SafeNavigation
           end
         end
 

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

@@ -7,7 +7,7 @@ require_relative 'instrumentation'
 module NewRelic::Agent::Instrumentation
   module Curb
     module Chain
-      def self.instrument!
+      def self.instrument! # rubocop:disable Metrics/AbcSize
         Curl::Easy.class_eval do
           include NewRelic::Agent::Instrumentation::Curb::Easy
 

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

@@ -68,6 +68,8 @@ module NewRelic
         module Multi
           include NewRelic::Agent::MethodTracer
 
+          INSTRUMENTATION_NAME = 'Curb'
+
           # Add CAT with callbacks if the request is serial
           def add_with_tracing(curl)
             if curl.respond_to?(:_nr_serial) && curl._nr_serial
@@ -81,7 +83,9 @@ module NewRelic
           def perform_with_tracing
             return yield if first_request_is_serial?
 
-            trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+            trace_execution_scoped('External/Multiple/Curb::Multi/perform') do
               yield
             end
           end
@@ -107,7 +111,7 @@ module NewRelic
               request._nr_instrumented = true
             end
           rescue => err
-            NewRelic::Agent.logger.error("Untrapped exception", err)
+            NewRelic::Agent.logger.error('Untrapped exception', err)
           end
 
           # Create request and response adapter objects for the specified +request+
@@ -141,12 +145,12 @@ module NewRelic
             request._nr_original_on_complete = original_callback
             request.on_complete do |finished_request|
               begin
-                segment.process_response_headers(wrapped_response) if segment
+                segment&.process_response_headers(wrapped_response)
               ensure
                 ::NewRelic::Agent::Transaction::Segment.finish(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
+                original_callback&.call(finished_request)
                 remove_instrumentation_callbacks(request)
               end
             end
@@ -173,7 +177,7 @@ module NewRelic
                   segment.notice_error(noticeable_error)
                 end
               ensure
-                original_callback.call(failed_request, error) if original_callback
+                original_callback&.call(failed_request, error)
                 remove_failure_callback(failed_request)
               end
             end

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

@@ -8,7 +8,7 @@ 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) &&

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

@@ -23,7 +23,8 @@ module NewRelic::Agent::Instrumentation
       NewRelic::Agent.notice_error(payload[:exception_object]) if payload.key?(:exception_object)
 
       finishable = pop_segment(id)
-      finishable.finish if finishable
+      # the following line needs else branch coverage
+      finishable.finish if finishable # rubocop:disable Style/SafeNavigation
     rescue => e
       log_notification_error(e, name, 'finish')
     end

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

@@ -1,6 +1,7 @@
 # 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

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

@@ -22,7 +22,7 @@ module NewRelic
             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")
+            NewRelic::Agent.logger.warn('Did not find a Delayed::Job class responding to invoke_job, aborting DJ instrumentation')
           end
         end
       end
@@ -31,8 +31,11 @@ module NewRelic
         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)

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

@@ -109,6 +109,7 @@ DependencyDetection.defer do
   end
 
   def delayed_job_version
-    Gem.loaded_specs['delayed_job'].version if Gem.loaded_specs['delayed_job']
+    # 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

@@ -3,10 +3,10 @@
 # frozen_string_literal: true
 
 module NewRelic::Agent::Instrumentation
-  module Elasticsearch
+  module Elasticsearch::Chain
     def self.instrument!
       to_instrument = if ::Gem::Version.create(::Elasticsearch::VERSION) <
-          ::Gem::Version.create("8.0.0")
+          ::Gem::Version.create('8.0.0')
         ::Elasticsearch::Transport::Client
       else
         ::Elastic::Transport::Client