newrelic_rpm 9.1.0 → 9.21.0

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,6 +83,8 @@ module NewRelic
           def perform_with_tracing
             return yield if first_request_is_serial?
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             trace_execution_scoped('External/Multiple/Curb::Multi/perform') do
               yield
             end

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

@@ -12,21 +12,20 @@ DependencyDetection.defer do
 
   depends_on do
     defined?(Curl) && defined?(Curl::CURB_VERSION) &&
-      Gem::Version.new(Curl::CURB_VERSION) >= CURB_MIN_VERSION
+      NewRelic::Helper.version_satisfied?(Curl::CURB_VERSION, '>=', CURB_MIN_VERSION)
   end
 
   executes do
-    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
     if use_prepend?
-      prepend_instrument Curl::Easy, NewRelic::Agent::Instrumentation::Curb::Easy::Prepend
-      prepend_instrument Curl::Multi, NewRelic::Agent::Instrumentation::Curb::Multi::Prepend
+      prepend_instrument Curl::Easy, NewRelic::Agent::Instrumentation::Curb::Easy::Prepend, 'Curb::Easy'
+      prepend_instrument Curl::Multi, NewRelic::Agent::Instrumentation::Curb::Multi::Prepend, 'Curb::Multi'
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Curb::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::Curb::Chain, NewRelic::Agent::Instrumentation::Curb::Multi::INSTRUMENTATION_NAME
     end
   end
 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

@@ -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

@@ -82,10 +82,6 @@ DependencyDetection.defer do
     defined?(Delayed) && defined?(Delayed::Worker)
   end
 
-  executes do
-    NewRelic::Agent.logger.info('Installing DelayedJob instrumentation [part 1/2]')
-  end
-
   executes do
     if use_prepend?
       prepend_instrument Delayed::Worker, NewRelic::Agent::Instrumentation::DelayedJob::Prepend
@@ -93,23 +89,4 @@ DependencyDetection.defer do
       chain_instrument NewRelic::Agent::Instrumentation::DelayedJob::Chain
     end
   end
-
-  executes do
-    next unless delayed_job_version < Gem::Version.new('4.1.0')
-
-    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. ' \
-
-    NewRelic::Agent.logger.log_once(
-      :warn,
-      :deprecated_delayed_job_version,
-      deprecation_msg
-    )
-  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/dynamodb/chain.rb

@@ -0,0 +1,27 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module DynamoDB::Chain
+    def self.instrument!
+      ::Aws::DynamoDB::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::DynamoDB
+
+        NewRelic::Agent::Instrumentation::DynamoDB::INSTRUMENTED_METHODS.each do |method_name|
+          alias_method("#{method_name}_without_new_relic".to_sym, method_name.to_sym)
+
+          define_method(method_name) do |*args|
+            instrument_method_with_new_relic(method_name, *args) { send("#{method_name}_without_new_relic".to_sym, *args) }
+          end
+        end
+
+        alias_method(:build_request_without_new_relic, :build_request)
+
+        def build_request(*args)
+          build_request_with_new_relic(*args) { build_request_without_new_relic(*args) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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 DynamoDB
+    INSTRUMENTED_METHODS = %w[
+      create_table
+      delete_item
+      delete_table
+      get_item
+      put_item
+      query
+      scan
+      update_item
+    ].freeze
+
+    PRODUCT = 'DynamoDB'
+    DEFAULT_HOST = 'dynamodb.amazonaws.com'
+
+    def instrument_method_with_new_relic(method_name, *args)
+      return yield unless NewRelic::Agent::Tracer.tracing_enabled?
+
+      NewRelic::Agent.record_instrumentation_invocation(PRODUCT)
+
+      segment = NewRelic::Agent::Tracer.start_datastore_segment(
+        product: PRODUCT,
+        operation: method_name,
+        host: config&.endpoint&.host || DEFAULT_HOST,
+        port_path_or_id: config&.endpoint&.port,
+        collection: args[0][:table_name]
+      )
+
+      arn = get_arn(args[0])
+      segment&.add_agent_attribute('cloud.resource_id', arn) if arn
+
+      @nr_captured_request = nil # clear request just in case
+      begin
+        NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+      ensure
+        segment&.add_agent_attribute('aws.operation', method_name)
+        segment&.add_agent_attribute('aws.requestId', @nr_captured_request&.context&.http_response&.headers&.[]('x-amzn-requestid'))
+        segment&.add_agent_attribute('aws.region', config&.region)
+        segment&.finish
+      end
+    end
+
+    def build_request_with_new_relic(*args)
+      @nr_captured_request = yield
+    end
+
+    def nr_account_id
+      return @nr_account_id if defined?(@nr_account_id)
+
+      @nr_account_id = NewRelic::Agent::Aws.get_account_id(config)
+    end
+
+    def get_arn(params)
+      return unless params[:table_name]
+
+      NewRelic::Agent::Aws.create_arn(PRODUCT.downcase, "table/#{params[:table_name]}", config&.region, nr_account_id)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# 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 DynamoDB::Prepend
+    include NewRelic::Agent::Instrumentation::DynamoDB
+
+    INSTRUMENTED_METHODS.each do |method_name|
+      define_method(method_name) do |*args|
+        instrument_method_with_new_relic(method_name, *args) { super(*args) }
+      end
+    end
+
+    def build_request(*args)
+      build_request_with_new_relic(*args) { super }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/dynamodb.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 'dynamodb/instrumentation'
+require_relative 'dynamodb/chain'
+require_relative 'dynamodb/prepend'
+
+DependencyDetection.defer do
+  named :dynamodb
+
+  depends_on do
+    defined?(Aws::DynamoDB::Client)
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument Aws::DynamoDB::Client, NewRelic::Agent::Instrumentation::DynamoDB::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::DynamoDB::Chain
+    end
+  end
+end

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

@@ -3,10 +3,9 @@
 # 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')
+      to_instrument = if NewRelic::Helper.version_satisfied?(::Elasticsearch::VERSION, '<', '8.0.0')
         ::Elasticsearch::Transport::Client
       else
         ::Elastic::Transport::Client

data/lib/new_relic/agent/instrumentation/elasticsearch/instrumentation.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 '../../datastores/nosql_obfuscator'
 
 module NewRelic::Agent::Instrumentation
@@ -8,16 +9,72 @@ module NewRelic::Agent::Instrumentation
     PRODUCT_NAME = 'Elasticsearch'
     OPERATION = 'perform_request'
 
-    def perform_request_with_tracing(method, path, params = {}, body = nil, headers = nil)
+    # Pattern to use with client caller location strings. Look for a location
+    # that contains '/lib/elasticsearch/api/' and is NOT followed by the
+    # string held in the OPERATION constant
+    OPERATION_PATTERN = %r{/lib/elasticsearch/api/(?!.+#{OPERATION})}.freeze
+
+    # Use the OPERATION_PATTERN pattern to find the appropriate caller location
+    # that will contain the client instance method (example: 'search') and
+    # return that method name.
+    #
+    # A Ruby caller location matching the OPERATION_PATTERN will contain an
+    # elasticsearch client instance method name (such as "search"), and that
+    # method name will be used as the operation name.
+    #
+    # With Ruby < 3.4 the method name is listed as:
+    #
+    #   `search'
+    #
+    # with an opening backtick and a closing single tick. And only the
+    # method name itself is listed.
+    #
+    # With Ruby 3.4+ the method name is listed as:
+    #
+    #   'Elasticsearch::API::Actions#search'
+    #
+    # with opening and closing single ticks and the class defining the
+    # instance method listed.
+    #
+    # (?:) = ?: prevents capturing
+    # (?:`|') = allow ` or '
+    # (?:.+#) = allow the class name and '#' prefix to exist but ignore it
+    # ([^']+)' = after the opening ` or ', capturing everything up to the
+    #            closing '.  [^']+ = one or more characters that are not '
+    #
+    # Example Ruby 3.3.1 input:
+    #
+    #   /Users/fallwith/.rubies/ruby-3.3.1/lib/ruby/gems/3.3.0/gems/elasticsearch-api-7.17.10/lib/elasticsearch/api/actions/index.rb:74:in `index'
+    #
+    # Example Ruby 3.4.0-preview1 input:
+    #
+    #   /Users/fallwith/.rubies/ruby-3.4.0-preview1/lib/ruby/gems/3.4.0+0/gems/elasticsearch-api-7.17.10/lib/elasticsearch/api/actions/index.rb:74:in 'Elasticsearch::API::Actions#index'
+    #
+    # Example output for both Rubies:
+    #
+    #   index
+
+    INSTANCE_METHOD_PATTERN = /:in (?:`|')(?:.+#)?([^']+)'\z/.freeze
+
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
+    # We need the positional arguments `params` and `body`
+    # to capture the nosql statement
+    # *args protects the instrumented method if new arguments are added to
+    # perform_request
+    def perform_request_with_tracing(_method, _path, params = {}, body = nil, _headers = nil, *_args)
       return yield unless NewRelic::Agent::Tracer.tracing_enabled?
 
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
         product: PRODUCT_NAME,
         operation: nr_operation || OPERATION,
         host: nr_hosts[:host],
-        port_path_or_id: path,
+        port_path_or_id: nr_hosts[:port],
         database_name: nr_cluster_name
       )
+
       begin
         NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
       ensure
@@ -31,13 +88,10 @@ module NewRelic::Agent::Instrumentation
     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
+      location = caller_locations.detect { |loc| loc.to_s.match?(OPERATION_PATTERN) }
+      return unless location && location.to_s =~ INSTANCE_METHOD_PATTERN
 
-      caller_locations[operation_index].to_s.split('`')[-1].gsub(/\W/, '')
+      Regexp.last_match(1)
     end
 
     def nr_reported_query(query)
@@ -48,11 +102,12 @@ module NewRelic::Agent::Instrumentation
     end
 
     def nr_cluster_name
-      return @nr_cluster_name if @nr_cluster_name
+      return unless NewRelic::Agent.config[:'elasticsearch.capture_cluster_name']
+      return @nr_cluster_name if defined?(@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']
+        @nr_cluster_name ||= perform_request('GET', '/').body['cluster_name']
       end
     rescue StandardError => e
       NewRelic::Agent.logger.error('Failed to get cluster name for elasticsearch', e)

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

@@ -14,9 +14,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing Elasticsearch instrumentation')
-
-    to_instrument = if Gem::Version.create(Elasticsearch::VERSION) < Gem::Version.create('8.0.0')
+    to_instrument = if NewRelic::Helper.version_satisfied?(Elasticsearch::VERSION, '<', '8.0.0')
       Elasticsearch::Transport::Client
     else
       Elastic::Transport::Client
@@ -25,7 +23,7 @@ DependencyDetection.defer do
     if use_prepend?
       prepend_instrument to_instrument, NewRelic::Agent::Instrumentation::Elasticsearch::Prepend
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Elasticsearch
+      chain_instrument NewRelic::Agent::Instrumentation::Elasticsearch::Chain
     end
   end
 end

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

@@ -0,0 +1,39 @@
+# 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 Ethon
+    module Chain
+      def self.instrument!
+        ::Ethon::Easy.class_eval do
+          include NewRelic::Agent::Instrumentation::Ethon::Easy
+
+          alias_method(:fabricate_without_tracing, :fabricate)
+          def fabricate(url, action_name, options)
+            fabricate_with_tracing(url, action_name, options) { fabricate_without_tracing(url, action_name, options) }
+          end
+
+          alias_method(:headers_equals_without_tracing, :headers=)
+          def headers=(headers)
+            headers_equals_with_tracing(headers) { headers_equals_without_tracing(headers) }
+          end
+
+          alias_method(:perform_without_tracing, :perform)
+          def perform(*args)
+            perform_with_tracing(*args) { perform_without_tracing(*args) }
+          end
+        end
+
+        ::Ethon::Multi.class_eval do
+          include NewRelic::Agent::Instrumentation::Ethon::Multi
+
+          alias_method(:perform_without_tracing, :perform)
+          def perform(*args)
+            perform_with_tracing(*args) { perform_without_tracing(*args) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# 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/ethon_wrappers'
+
+module NewRelic::Agent::Instrumentation
+  module Ethon
+    module NRShared
+      INSTRUMENTATION_NAME = 'Ethon'
+      NOTICEABLE_ERROR_CLASS = 'Ethon::Errors::EthonError'
+
+      def prep_easy(easy, parent = nil)
+        wrapped_request = NewRelic::Agent::HTTPClients::EthonHTTPRequest.new(easy)
+        segment = NewRelic::Agent::Tracer.start_external_request_segment(
+          library: wrapped_request.type,
+          uri: wrapped_request.uri,
+          procedure: wrapped_request.method,
+          parent: parent
+        )
+        segment.add_request_headers(wrapped_request)
+
+        callback = proc do
+          wrapped_response = NewRelic::Agent::HTTPClients::EthonHTTPResponse.new(easy)
+          segment.process_response_headers(wrapped_response)
+
+          if easy.return_code != :ok
+            e = NewRelic::Agent::NoticeableError.new(NOTICEABLE_ERROR_CLASS,
+              "return_code: >>#{easy.return_code}<<, response_code: >>#{easy.response_code}<<")
+            segment.notice_error(e)
+          end
+
+          ::NewRelic::Agent::Transaction::Segment.finish(segment)
+        end
+
+        easy.on_complete { callback.call }
+
+        segment
+      end
+
+      def wrap_with_tracing(segment, &block)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        NewRelic::Agent::Tracer.capture_segment_error(segment) do
+          yield
+        end
+      ensure
+        NewRelic::Agent::Transaction::Segment.finish(segment)
+      end
+    end
+
+    module Easy
+      include NRShared
+
+      ACTION_INSTANCE_VAR = :@nr_action
+      HEADERS_INSTANCE_VAR = :@nr_headers
+
+      # `Ethon::Easy` doesn't expose the "action name" ('GET', 'POST', etc.)
+      # and Ethon's fabrication of HTTP classes uses
+      # `Ethon::Easy::Http::Custom` for non-standard actions. To be able to
+      # know the action name at `#perform` time, we set a new instance variable
+      # on the `Ethon::Easy` instance with the base name of the fabricated
+      # class, respecting the 'Custom' name where appropriate.
+      def fabricate_with_tracing(_url, action_name, _options)
+        fabbed = yield
+        instance_variable_set(ACTION_INSTANCE_VAR, NewRelic::Agent.base_name(fabbed.class.name).upcase)
+        fabbed
+      end
+
+      # `Ethon::Easy` uses `Ethon::Easy::Header` to set request headers on
+      # libcurl with `#headers=`. After they are set, they aren't easy to get
+      # at again except via FFI so set a new instance variable on the
+      # `Ethon::Easy` instance to store them in Ruby hash format.
+      def headers_equals_with_tracing(headers)
+        instance_variable_set(HEADERS_INSTANCE_VAR, headers)
+        yield
+      end
+
+      def perform_with_tracing(*args)
+        return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+        segment = prep_easy(self)
+        wrap_with_tracing(segment) { yield }
+      end
+    end
+
+    module Multi
+      include NRShared
+
+      MULTI_SEGMENT_NAME = 'External/Multiple/Ethon::Multi/perform'
+
+      def perform_with_tracing(*args)
+        return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+        segment = NewRelic::Agent::Tracer.start_segment(name: MULTI_SEGMENT_NAME)
+
+        wrap_with_tracing(segment) do
+          easy_handles.each { |easy| prep_easy(easy, segment) }
+
+          yield
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module Ethon
+    module Easy
+      module Prepend
+        include NewRelic::Agent::Instrumentation::Ethon::Easy
+
+        def fabricate(url, action_name, options)
+          fabricate_with_tracing(url, action_name, options) { super }
+        end
+
+        def headers=(headers)
+          headers_equals_with_tracing(headers) { super }
+        end
+
+        def perform(*args)
+          perform_with_tracing(*args) { super }
+        end
+      end
+    end
+
+    module Multi
+      module Prepend
+        include NewRelic::Agent::Instrumentation::Ethon::Multi
+
+        def perform(*args)
+          perform_with_tracing(*args) { super }
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/ethon.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 'ethon/instrumentation'
+require_relative 'ethon/chain'
+require_relative 'ethon/prepend'
+
+DependencyDetection.defer do
+  named :ethon
+
+  # If Ethon is being used as a dependency of Typhoeus, allow the Typhoeus
+  # instrumentation to handle everything. Otherwise each external network call
+  # will confusingly result in "Ethon" segments duplicating the information
+  # already provided by "Typhoeus" segments.
+  depends_on do
+    !defined?(Typhoeus)
+  end
+
+  depends_on do
+    defined?(Ethon) && NewRelic::Helper.version_satisfied?(Ethon::VERSION, '>=', '0.12.0')
+  end
+
+  executes do
+    if use_prepend?
+      # NOTE: by default prepend_instrument will go with the module name that
+      #       precedes 'Prepend' (so 'Easy' and 'Multi'), but we want to use
+      #       'Ethon::Easy' and 'Ethon::Multi' so 3rd argument is supplied
+      prepend_instrument Ethon::Easy, NewRelic::Agent::Instrumentation::Ethon::Easy::Prepend, Ethon::Easy.name
+      prepend_instrument Ethon::Multi, NewRelic::Agent::Instrumentation::Ethon::Multi::Prepend, Ethon::Multi.name
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Ethon::Chain
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ module ::Excon
   module Middleware
     class NewRelicCrossAppTracing
       TRACE_DATA_IVAR = :@newrelic_trace_data
+      INSTRUMENTATION_NAME = 'Excon'
 
       def initialize(stack)
         @stack = stack
@@ -18,6 +19,8 @@ module ::Excon
           # :idempotent in the options, but there will be only a single
           # accompanying response_call/error_call.
           if datum[:connection] && !datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             wrapped_request = ::NewRelic::Agent::HTTPClients::ExconHTTPRequest.new(datum)
             segment = NewRelic::Agent::Tracer.start_external_request_segment(
               library: wrapped_request.type,

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

@@ -26,29 +26,13 @@ DependencyDetection.defer do
 
   executes do
     excon_version = Gem::Version.new(Excon::VERSION)
-    if excon_version >= EXCON_MIN_VERSION
+    if NewRelic::Helper.version_satisfied?(excon_version, '>=', EXCON_MIN_VERSION)
       install_excon_instrumentation(excon_version)
     else
       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/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/excon_wrappers'