newrelic_rpm 6.8.0.360 → 8.13.1

data/lib/new_relic/agent/instrumentation/data_mapper.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
 
 DependencyDetection.defer do
   named :data_mapper
@@ -13,74 +13,85 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing DataMapper instrumentation'
+    ::NewRelic::Agent.logger.info('Installing DataMapper instrumentation')
     require 'new_relic/agent/datastores/metric_helper'
+
+    deprecation_msg = 'The instrumentation for DataMapper is deprecated. ' \
+     'It will be removed in version 9.0.0.' \
+     'Visit https://docs.newrelic.com/docs/apm/agents/ruby-agent/getting-started/ruby-agent-requirements-supported-frameworks ' \
+     'to learn about supported gems.'
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_datamapper,
+      deprecation_msg
+    )
   end
 
   executes do
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :get
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :first
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :last
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :all
-
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :create
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :create!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :update
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :update!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :destroy
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :destroy!
-
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :aggregate
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :find
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :find_by_sql
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :get)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :first)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :last)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :all)
+
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :create)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :create!)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :update)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :update!)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :destroy)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :destroy!)
+
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :aggregate)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :find)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Model, :find_by_sql)
   end
 
   executes do
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :update
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :update!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :save
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :save!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :destroy
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :destroy!
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Resource, :update)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Resource, :update!)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Resource, :save)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Resource, :save!)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Resource, :destroy)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Resource, :destroy!)
   end
 
   executes do
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :get
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :first
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :last
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :all
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :get)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :first)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :last)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :all)
 
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :lazy_load
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :lazy_load)
 
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :create
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :create!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :update
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :update!
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :destroy
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :destroy!
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :create)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :create!)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :update)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :update!)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :destroy)
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :destroy!)
 
-    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :aggregate
+    NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Collection, :aggregate)
   end
 
   executes do
     # Catch direct SQL calls that bypass CRUD
     if defined?(::DataMapper::Adapters::DataObjectsAdapter)
-      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Adapters::DataObjectsAdapter, :select, true
-      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Adapters::DataObjectsAdapter, :execute, true
+      NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Adapters::DataObjectsAdapter, :select, true)
+      NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Adapters::DataObjectsAdapter, :execute, true)
     end
   end
 
   executes do
     # DM::Validations overrides Model#create, so we patch it here as well
     if defined?(::DataMapper::Validations::ClassMethods)
-      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Validations::ClassMethods, :create
+      NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Validations::ClassMethods, :create)
     end
   end
 
   executes do
     # DM::Transaction calls commit() twice, so potentially shows up twice.
     if defined?(::DataMapper::Transaction)
-      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Transaction, :commit, true
+      NewRelic::Agent::DataMapperTracing.add_tracer(::DataMapper::Transaction, :commit, true)
     end
   end
 
@@ -100,10 +111,10 @@ module NewRelic
         clazz.class_eval do
           if method_defined?(method_name) || private_method_defined?(method_name)
             define_method("#{method_name}_with_newrelic",
-                          NewRelic::Agent::DataMapperTracing.method_body(clazz, method_name, operation_only))
+              NewRelic::Agent::DataMapperTracing.method_body(clazz, method_name, operation_only))
 
-            alias_method "#{method_name}_without_newrelic", method_name
-            alias_method method_name, "#{method_name}_with_newrelic"
+            alias_method("#{method_name}_without_newrelic", method_name)
+            alias_method(method_name, "#{method_name}_with_newrelic")
           end
         end
       end
@@ -114,10 +125,10 @@ module NewRelic
       PASSWORD_PARAM = '&password='.freeze
 
       def self.method_body(clazz, method_name, operation_only)
-        use_model_name   = NewRelic::Helper.instance_methods_include?(clazz, :model)
+        use_model_name = NewRelic::Helper.instance_methods_include?(clazz, :model)
         metric_operation = method_name.to_s.gsub(/[!?]/, "")
 
-        Proc.new do |*args, &blk|
+        proc do |*args, &blk|
           begin
             if operation_only
               # Used by direct SQL, like ::DataMapper::Adapters::DataObjectsAdapter#select
@@ -140,7 +151,9 @@ module NewRelic
             )
 
             begin
-              self.send("#{method_name}_without_newrelic", *args, &blk)
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                self.send("#{method_name}_without_newrelic", *args, &blk)
+              end
             rescue ::DataObjects::ConnectionError => e
               raise
             rescue ::DataObjects::SQLError => e
@@ -150,15 +163,15 @@ module NewRelic
               case strategy
               when :obfuscated
                 adapter_name = if self.respond_to?(:options)
-                    self.options[:adapter]
+                  self.options[:adapter]
+                else
+                  if self.repository.adapter.respond_to?(:options)
+                    self.repository.adapter.options[:adapter]
                   else
-                    if self.repository.adapter.respond_to?(:options)
-                      self.repository.adapter.options[:adapter]
-                    else
-                      # DataMapper < 0.10.0
-                      self.repository.adapter.uri.scheme
-                    end
+                    # DataMapper < 0.10.0
+                    self.repository.adapter.uri.scheme
                   end
+                end
                 statement = NewRelic::Agent::Database::Statement.new(e.query, :adapter => adapter_name)
                 obfuscated_sql = NewRelic::Agent::Database.obfuscate_sql(statement)
                 e.instance_variable_set(:@query, obfuscated_sql)
@@ -184,14 +197,14 @@ module NewRelic
         # We rely on the assumption that all possible entry points have been
         # hooked with tracers, ensuring that notice_sql attaches this SQL to
         # the proper call scope.
-        def log(msg) #THREAD_LOCAL_ACCESS
+        def log(msg) # THREAD_LOCAL_ACCESS
           state = NewRelic::Agent::Tracer.state
           return unless state.is_execution_traced?
 
           txn = state.current_transaction
 
           if txn && txn.current_segment.respond_to?(:notice_sql)
-            txn.current_segment.notice_sql msg.query
+            txn.current_segment.notice_sql(msg.query)
           end
         ensure
           super

data/lib/new_relic/agent/instrumentation/delayed_job/chain.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
+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,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,36 @@ 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
+    Gem.loaded_specs['delayed_job'].version if Gem.loaded_specs['delayed_job']
   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
+    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,66 @@
+# 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
+    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,15 +45,16 @@ module ::Excon
         @stack.error_call(datum)
       end
 
-      def finish_trace(datum) #THREAD_LOCAL_ACCESS
+      def finish_trace(datum) # THREAD_LOCAL_ACCESS
         segment = datum[:connection] && datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
         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