newrelic_rpm 9.1.0 → 9.21.0

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

@@ -5,8 +5,8 @@
 # NOTE: there are multiple implementations of the Memcached client in Ruby,
 # each with slightly different APIs and semantics.
 # See:
-#     http://www.deveiate.org/code/Ruby-MemCache/ (Gem: Ruby-MemCache)
-#     http://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
+#     https://rubygems.org/gems/Ruby-MemCache (Gem: Ruby-MemCache)
+#     https://github.com/mperham/memcache-client (Gem: memcache-client)
 #     https://github.com/mperham/dalli (Gem: dalli)
 
 require_relative 'memcache/helper'
@@ -58,7 +58,7 @@ DependencyDetection.defer do
         prepend_instrument client_class, instrumenting_module, 'MemcachedDalli'
       end
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Memcache::Dalli
+      chain_instrument NewRelic::Agent::Instrumentation::Memcache::Dalli, 'MemcachedDalli'
     end
   end
 end
@@ -74,14 +74,13 @@ DependencyDetection.defer do
   depends_on { NewRelic::Agent::Instrumentation::Memcache::DalliCAS.should_instrument? }
 
   executes do
-    NewRelic::Agent.logger.info('Installing Dalli CAS Client Memcache instrumentation')
     if use_prepend?
       prepend_module = NewRelic::Agent::Instrumentation::Memcache::Prepend
       prepend_module.dalli_cas_prependers do |client_class, instrumenting_module|
         prepend_instrument client_class, instrumenting_module, 'MemcachedDalliCAS'
       end
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Memcache::DalliCAS
+      chain_instrument NewRelic::Agent::Instrumentation::Memcache::DalliCAS, 'MemcachedDalliCAS'
     end
   end
 end

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

@@ -21,7 +21,7 @@ module NewRelic
           end
         end
 
-        ERROR_KEYS = %w[ writeErrors writeConcernError writeConcernErrors ].freeze
+        ERROR_KEYS = %w[writeErrors writeConcernError writeConcernErrors].freeze
 
         def error_key_present?(event)
           if reply = event.reply
@@ -106,7 +106,7 @@ module NewRelic
           )
         end
 
-        UNKNOWN = 'unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN_LOWER
         LOCALHOST = 'localhost'.freeze
 
         def host_from_address(address)
@@ -131,10 +131,8 @@ module NewRelic
           UNKNOWN
         end
 
-        SLASH = '/'.freeze
-
         def unix_domain_socket?(host)
-          host.start_with?(SLASH)
+          host.start_with?(NewRelic::SLASH)
         end
       end
     end

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

@@ -6,7 +6,11 @@ module NewRelic
   module Agent
     module Instrumentation
       module NetHTTP
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
         def request_with_tracing(request)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
 
           segment = NewRelic::Agent::Tracer.start_external_request_segment(
@@ -17,7 +21,7 @@ module NewRelic
 
           begin
             response = nil
-            segment.add_request_headers(wrapped_request)
+            segment&.add_request_headers(wrapped_request)
 
             # RUBY-1244 Disable further tracing in request to avoid double
             # counting if connection wasn't started (which calls request again).
@@ -28,10 +32,16 @@ module NewRelic
             end
 
             wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new(response)
-            segment.process_response_headers(wrapped_response)
+
+            if NewRelic::Agent::LLM.openai_parent?(segment)
+              NewRelic::Agent::LLM.populate_openai_response_headers(wrapped_response, segment&.parent)
+            end
+
+            segment&.process_response_headers(wrapped_response)
+
             response
           ensure
-            segment.finish
+            segment&.finish
           end
         end
       end

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

@@ -19,7 +19,8 @@ DependencyDetection.defer do
 
   # Airbrake uses method chaining on Net::HTTP in versions < 10.0.2 (10.0.2 updated to prepend for Net:HTTP)
   conflicts_with_prepend do
-    defined?(Airbrake) && defined?(Airbrake::AIRBRAKE_VERSION) && Gem::Version.create(Airbrake::AIRBRAKE_VERSION) < Gem::Version.create('10.0.2')
+    defined?(Airbrake) && defined?(Airbrake::AIRBRAKE_VERSION) &&
+      NewRelic::Helper.version_satisfied?(Airbrake::AIRBRAKE_VERSION, '<', '10.0.2')
   end
 
   conflicts_with_prepend do

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

@@ -16,8 +16,6 @@ module NewRelic
         end
 
         def self.find_all_subscribers
-          # TODO: need to talk to Rails core about an API for this,
-          # rather than digging through Listener ivars
           instance_variable_names = [:@subscribers, :@string_subscribers, :@other_subscribers]
           all_subscribers = []
 
@@ -47,6 +45,10 @@ module NewRelic
           end
         end
 
+        # The agent doesn't use the traditional ActiveSupport::Notifications.subscribe
+        # pattern due to threading issues discovered on initial instrumentation.
+        # Instead we define a #start and #finish method, which Rails responds to.
+        # See: https://github.com/rails/rails/issues/12069
         def start(name, id, payload)
           return unless state.is_execution_traced?
 

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

@@ -0,0 +1,21 @@
+# 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 OpenSearch::Chain
+    def self.instrument!
+      ::OpenSearch::Transport::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::OpenSearch
+
+        alias_method(:perform_request_without_tracing, :perform_request)
+
+        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/opensearch/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
+
+module NewRelic::Agent::Instrumentation
+  module OpenSearch
+    PRODUCT_NAME = 'OpenSearch'
+    OPERATION = 'perform_request'
+    OPERATION_PATTERN = %r{/lib/opensearch/api/(?!.+#{OPERATION})}
+    INSTANCE_METHOD_PATTERN = /:in (?:`|')(?:.+#)?([^']+)'\z/
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
+    def perform_request_with_tracing(_method, _path, params = NewRelic::EMPTY_HASH, body = nil, _headers = nil, _opts = nil, &_block)
+      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: nr_hosts[:port],
+        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
+
+    # See Elasticsearch instrumentation for explanation on Ruby 3.4 changes to match instance method
+    def nr_operation
+      location = caller_locations.detect { |loc| loc.to_s.match?(OPERATION_PATTERN) }
+      return unless location && location.to_s =~ INSTANCE_METHOD_PATTERN
+
+      Regexp.last_match(1)
+    end
+
+    def nr_reported_query(query)
+      return unless NewRelic::Agent.config[:'opensearch.capture_queries']
+      return query unless NewRelic::Agent.config[:'opensearch.obfuscate_queries']
+
+      NewRelic::Agent::Datastores::NosqlObfuscator.obfuscate_statement(query)
+    end
+
+    def nr_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', '/').body['cluster_name']
+      end
+    rescue StandardError => e
+      NewRelic::Agent.logger.error('Failed to get cluster name for OpenSearch', e)
+      nil
+    end
+
+    def nr_hosts
+      @nr_hosts ||= (transport.hosts.first || NewRelic::EMPTY_HASH)
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/opensearch/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 OpenSearch::Prepend
+    include NewRelic::Agent::Instrumentation::OpenSearch
+
+    def perform_request(*args)
+      perform_request_with_tracing(*args) { super }
+    end
+  end
+end

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

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

@@ -4,7 +4,11 @@
 
 module NewRelic::Agent::Instrumentation
   module Padrino
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def invoke_route_with_tracing(*args)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       begin
         env['newrelic.last_route'] = args[0].original_path
       rescue => e

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

@@ -22,11 +22,11 @@ DependencyDetection.defer do
   depends_on { defined?(Padrino) && defined?(Padrino::Routing::InstanceMethods) }
 
   executes do
-    NewRelic::Agent.logger.info('Installing Padrino instrumentation')
+    supportability_name = NewRelic::Agent::Instrumentation::Padrino::INSTRUMENTATION_NAME
     if use_prepend?
-      prepend_instrument Padrino::Application, NewRelic::Agent::Instrumentation::PadrinoTracer::Prepend
+      prepend_instrument Padrino::Application, NewRelic::Agent::Instrumentation::PadrinoTracer::Prepend, supportability_name
     else
-      chain_instrument NewRelic::Agent::Instrumentation::PadrinoTracer::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::PadrinoTracer::Chain, supportability_name
     end
   end
 end

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

@@ -5,7 +5,7 @@
 module NewRelic
   module Agent
     module Instrumentation
-      # https://newrelic.com/docs/features/tracking-front-end-time
+      # https://docs.newrelic.com/docs/features/tracking-front-end-time
       # Record queue time metrics based on any of three headers
       # which can be set on the request.
       module QueueTime

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

@@ -6,11 +6,14 @@ module NewRelic
   module Agent
     module Instrumentation
       module RackBuilder
+        INSTRUMENTATION_NAME = 'Rack'
+
         def self.track_deferred_detection(builder_class)
           class << builder_class
             attr_accessor :_nr_deferred_detection_ran
           end
           builder_class._nr_deferred_detection_ran = false
+          NewRelic::Control::SecurityInterface.instance.wait = true
         end
 
         def deferred_dependency_check
@@ -19,6 +22,8 @@ module NewRelic
           NewRelic::Agent.logger.info('Doing deferred dependency-detection before Rack startup')
           DependencyDetection.detect!
           self.class._nr_deferred_detection_ran = true
+          NewRelic::Control::SecurityInterface.instance.wait = false
+          NewRelic::Control::SecurityInterface.instance.init_agent
         end
 
         def check_for_late_instrumentation(app)
@@ -51,6 +56,8 @@ module NewRelic
         def run_with_tracing(app)
           return yield(app) unless middleware_instrumentation_enabled?
 
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true))
         end
 
@@ -58,6 +65,8 @@ module NewRelic
           return if middleware_class.nil?
           return yield(middleware_class) unless middleware_instrumentation_enabled?
 
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class))
         end
       end

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -9,6 +9,8 @@ module NewRelic
     module Instrumentation
       module Rails3
         module ActionController
+          INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
           # determine the path that is used in the metric name for
           # the called controller action
           def newrelic_metric_path(action_name_override = nil)
@@ -21,6 +23,8 @@ module NewRelic
           end
 
           def process_action(*args) # THREAD_LOCAL_ACCESS
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(request.filtered_parameters)
             perform_action_with_newrelic_trace(:category => :controller,
               :name => self.action_name,

data/lib/new_relic/agent/instrumentation/rails_notifications/action_cable.rb

@@ -25,7 +25,7 @@ DependencyDetection.defer do
 
   executes do
     # enumerate the specific events we want so that we do not get unexpected additions in the future
-    ActiveSupport::Notifications.subscribe(/\A(?:perform_action|transmit|broadcast)\.action_cable\z/,
+    ActiveSupport::Notifications.subscribe(/\A(?:perform_action|transmit.*|broadcast)\.action_cable\z/,
       NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
 
     ActiveSupport.on_load(:action_cable) do

data/lib/new_relic/agent/instrumentation/rails_notifications/action_controller.rb

@@ -32,14 +32,19 @@ DependencyDetection.defer do
     NewRelic::Agent::Instrumentation::ActionControllerSubscriber \
       .subscribe(/^process_action.action_controller$/)
 
-    subs = %w[send_file
-      send_data
-      redirect_to
+    subs = %w[exist_fragment?
+      expire_fragment
       halted_callback
-      unpermitted_parameters]
+      read_fragment
+      redirect_to
+      send_data
+      send_file
+      send_stream
+      write_fragment
+      unpermitted_parameters].map { |s| Regexp.escape(s) }
 
     # have to double escape period because its going from string -> regex
     NewRelic::Agent::Instrumentation::ActionControllerOtherSubscriber \
-      .subscribe(Regexp.new("^(#{subs.join('|')})\\.action_controller$"))
+      .subscribe(Regexp.new("^(?:#{subs.join('|')})\\.action_controller$"))
   end
 end

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

@@ -7,11 +7,15 @@ module NewRelic
     module Instrumentation
       module Rake
         module Tracer
+          INSTRUMENTATION_NAME = 'Rake'
+
           def invoke_with_newrelic_tracing(*args)
             unless NewRelic::Agent::Instrumentation::Rake.should_trace?(name)
               return yield
             end
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               timeout = NewRelic::Agent.config[:'rake.connect_timeout']
               NewRelic::Agent.instance.wait_on_connect(timeout)

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

@@ -12,12 +12,11 @@ DependencyDetection.defer do
   configure_with :rake
 
   depends_on { defined?(Rake) && defined?(Rake::VERSION) }
-  depends_on { Gem::Version.new(Rake::VERSION) >= Gem::Version.new('10.0.0') }
+  depends_on { NewRelic::Helper.version_satisfied?(Rake::VERSION, '>=', '10.0.0') }
   depends_on { NewRelic::Agent.config[:'rake.tasks'].any? }
   depends_on { NewRelic::Agent::Instrumentation::Rake.safe_from_third_party_gem? }
 
   executes do
-    NewRelic::Agent.logger.info('Installing Rake instrumentation')
     NewRelic::Agent.logger.debug("Instrumenting Rake tasks: #{NewRelic::Agent.config[:'rake.tasks']}")
   end
 

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

@@ -0,0 +1,72 @@
+# 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 Rdkafka::Chain
+    def self.instrument!
+      ::Rdkafka::Producer.class_eval do
+        include NewRelic::Agent::Instrumentation::Rdkafka
+
+        alias_method(:produce_without_new_relic, :produce)
+
+        def produce(**kwargs)
+          produce_with_new_relic(kwargs) do |headers|
+            kwargs[:headers] = headers
+            produce_without_new_relic(**kwargs)
+          end
+        end
+      end
+
+      ::Rdkafka::Consumer.class_eval do
+        include NewRelic::Agent::Instrumentation::Rdkafka
+
+        alias_method(:each_without_new_relic, :each)
+
+        def each(**kwargs)
+          each_without_new_relic(**kwargs) do |message|
+            each_with_new_relic(message) do
+              yield(message)
+            end
+          end
+        end
+      end
+
+      ::Rdkafka::Config.class_eval do
+        include NewRelic::Agent::Instrumentation::RdkafkaConfig
+
+        alias_method(:producer_without_new_relic, :producer)
+        alias_method(:consumer_without_new_relic, :consumer)
+
+        if NewRelic::Helper.version_satisfied?(::Rdkafka::VERSION, '>=', '0.16.0') ||
+            NewRelic::Helper.version_satisfied?(RUBY_VERSION, '>=', '2.7.0')
+          def producer(**kwargs)
+            producer_without_new_relic(**kwargs).tap do |producer|
+              set_nr_config(producer)
+            end
+          end
+
+          def consumer(**kwargs)
+            consumer_without_new_relic(**kwargs).tap do |consumer|
+              set_nr_config(consumer)
+            end
+          end
+        else
+          def producer
+            producer_without_new_relic.tap do |producer|
+              set_nr_config(producer)
+            end
+          end
+
+          def consumer
+            consumer_without_new_relic.tap do |consumer|
+              set_nr_config(consumer)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# 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/messaging'
+
+module NewRelic::Agent::Instrumentation
+  module Rdkafka
+    MESSAGING_LIBRARY = 'Kafka'
+    PRODUCE = 'Produce'
+    CONSUME = 'Consume'
+
+    INSTRUMENTATION_NAME = 'Rdkafka'
+
+    def produce_with_new_relic(*args)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      topic_name = args[0][:topic]
+      segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+        action: :produce,
+        library: MESSAGING_LIBRARY,
+        destination_type: :topic,
+        destination_name: topic_name
+      )
+      create_kafka_metrics(action: PRODUCE, topic: topic_name)
+
+      headers = args[0][:headers] || {}
+      ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
+
+      NewRelic::Agent::Tracer.capture_segment_error(segment) { yield(headers) }
+    ensure
+      segment&.finish
+    end
+
+    def each_with_new_relic(message)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      headers = message&.headers || {}
+      topic_name = message&.topic
+
+      NewRelic::Agent::Messaging.wrap_message_broker_consume_transaction(
+        library: MESSAGING_LIBRARY,
+        destination_type: :topic,
+        destination_name: topic_name,
+        headers: headers,
+        action: :consume
+      ) do
+        create_kafka_metrics(action: CONSUME, topic: topic_name)
+        yield
+      end
+    end
+
+    def create_kafka_metrics(action:, topic:)
+      hosts = []
+      # both 'bootstrap.servers' and 'metadata.broker.list' are valid ways to specify the Kafka server
+      hosts << @nr_config[:'bootstrap.servers'] if @nr_config[:'bootstrap.servers']
+      hosts << @nr_config[:'metadata.broker.list'] if @nr_config[:'metadata.broker.list']
+      hosts.each do |host|
+        NewRelic::Agent.record_metric("MessageBroker/Kafka/Nodes/#{host}/#{action}/#{topic}", 1)
+        NewRelic::Agent.record_metric("MessageBroker/Kafka/Nodes/#{host}", 1)
+      end
+    end
+  end
+
+  module RdkafkaConfig
+    def set_nr_config(producer_or_consumer)
+      producer_or_consumer.instance_variable_set(:@nr_config, self)
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rdkafka/prepend.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 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module RdkafkaProducer
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Rdkafka
+
+      def produce(**kwargs)
+        produce_with_new_relic(kwargs) do |headers|
+          kwargs[:headers] = headers
+          super
+        end
+      end
+    end
+  end
+
+  module RdkafkaConsumer
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Rdkafka
+
+      def each
+        super do |message|
+          each_with_new_relic(message) do
+            yield(message)
+          end
+        end
+      end
+    end
+  end
+
+  module RdkafkaConfig
+    module Prepend
+      include NewRelic::Agent::Instrumentation::RdkafkaConfig
+
+      if (defined?(::Rdkafka) && NewRelic::Helper.version_satisfied?(::Rdkafka::VERSION, '>=', '0.16.0')) ||
+          NewRelic::Helper.version_satisfied?(RUBY_VERSION, '>=', '2.7.0')
+        def producer(**kwargs)
+          super.tap do |producer|
+            set_nr_config(producer)
+          end
+        end
+
+        def consumer(**kwargs)
+          super.tap do |consumer|
+            set_nr_config(consumer)
+          end
+        end
+      else # older versions
+        def producer
+          super.tap do |producer|
+            set_nr_config(producer)
+          end
+        end
+
+        def consumer
+          super.tap do |consumer|
+            set_nr_config(consumer)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rdkafka.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
+
+DependencyDetection.defer do
+  named :rdkafka
+
+  depends_on do
+    defined?(Rdkafka)
+  end
+
+  executes do
+    require_relative 'rdkafka/instrumentation'
+    require_relative 'rdkafka/chain'
+    require_relative 'rdkafka/prepend'
+
+    if use_prepend?
+      prepend_instrument Rdkafka::Config, NewRelic::Agent::Instrumentation::RdkafkaConfig::Prepend
+      prepend_instrument Rdkafka::Producer, NewRelic::Agent::Instrumentation::RdkafkaProducer::Prepend
+      prepend_instrument Rdkafka::Consumer, NewRelic::Agent::Instrumentation::RdkafkaConsumer::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Rdkafka::Chain
+    end
+  end
+end