newrelic_rpm 9.7.0 → 9.16.1

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

@@ -33,22 +33,6 @@ DependencyDetection.defer do
     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'

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

@@ -14,8 +14,6 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing Fiber instrumentation')
-
     if use_prepend?
       prepend_instrument Fiber, NewRelic::Agent::Instrumentation::MonitoredFiber::Prepend
     else

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

@@ -19,7 +19,7 @@ DependencyDetection.defer do
 
   depends_on do
     begin
-      if defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?('newrelic-grape')
+      if NewRelic::Helper.rubygems_specs.map(&:name).include?('newrelic-grape')
         NewRelic::Agent.logger.info('Not installing New Relic supported Grape instrumentation because the third party newrelic-grape gem is present')
         false
       else

data/lib/new_relic/agent/instrumentation/grpc/client/instrumentation.rb

@@ -50,7 +50,6 @@ module NewRelic
             attributes_hash.each do |attr, value|
               segment.add_agent_attribute(attr, value)
             end
-            segment.record_agent_attributes = true
           end
 
           def grpc_status_and_message_from_exception(exception)

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

@@ -14,7 +14,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    supportability_name = NewRelic::Agent::Instrumentation::GRPC::Client::INSTRUMENTATION_NAME
+    supportability_name = NewRelic::Agent::Instrumentation::GRPC::Server::INSTRUMENTATION_NAME
     if use_prepend?
       prepend_instrument GRPC::RpcServer, NewRelic::Agent::Instrumentation::GRPC::Server::RpcServerPrepend, supportability_name
       prepend_instrument GRPC::RpcDesc, NewRelic::Agent::Instrumentation::GRPC::Server::RpcDescPrepend, supportability_name

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

@@ -23,7 +23,6 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing HTTPClient instrumentation')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/httpclient_wrappers'
   end

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

@@ -14,7 +14,6 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing http.rb Wrappers')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/http_rb_wrappers'
   end

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

@@ -13,10 +13,6 @@ DependencyDetection.defer do
     defined?(HTTPX) && Gem::Version.new(HTTPX::VERSION) >= Gem::Version.new('1.0.0')
   end
 
-  executes do
-    NewRelic::Agent.logger.info('Installing httpx instrumentation')
-  end
-
   executes do
     if use_prepend?
       prepend_instrument HTTPX::Session, NewRelic::Agent::Instrumentation::HTTPX::Prepend

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

@@ -15,12 +15,10 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info('Installing Logger instrumentation')
-
     if use_prepend?
       prepend_instrument Logger, NewRelic::Agent::Instrumentation::Logger::Prepend
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Logger
+      chain_instrument NewRelic::Agent::Instrumentation::Logger, NewRelic::Agent::Instrumentation::Logger::INSTRUMENTATION_NAME
     end
   end
 end

data/lib/new_relic/agent/instrumentation/logstasher/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 LogStasher::Chain
+    def self.instrument!
+      ::LogStasher.singleton_class.class_eval do
+        include NewRelic::Agent::Instrumentation::LogStasher
+
+        alias_method(:build_logstash_event_without_new_relic, :build_logstash_event)
+
+        def build_logstash_event(*args)
+          build_logstash_event_with_new_relic(*args) do
+            build_logstash_event_without_new_relic(*args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module LogStasher
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
+    def self.enabled?
+      NewRelic::Agent.config[:'instrumentation.logstasher'] != 'disabled'
+    end
+
+    def build_logstash_event_with_new_relic(*args)
+      logstasher_event = yield
+      log = logstasher_event.instance_variable_get(:@data)
+
+      ::NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+      ::NewRelic::Agent.agent.log_event_aggregator.record_logstasher_event(log)
+      ::NewRelic::Agent::LocalLogDecorator.decorate(log)
+
+      logstasher_event
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/logstasher/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 LogStasher::Prepend
+    include NewRelic::Agent::Instrumentation::LogStasher
+
+    def build_logstash_event(*args)
+      build_logstash_event_with_new_relic(*args) { super }
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'logstasher/instrumentation'
+require_relative 'logstasher/chain'
+require_relative 'logstasher/prepend'
+
+DependencyDetection.defer do
+  named :logstasher
+
+  depends_on do
+    defined?(LogStasher) &&
+      Gem::Version.new(LogStasher::VERSION) >= Gem::Version.new('1.0.0') &&
+      NewRelic::Agent.config[:'application_logging.enabled']
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument LogStasher.singleton_class, NewRelic::Agent::Instrumentation::LogStasher::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::LogStasher::Chain
+    end
+  end
+end

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

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

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

@@ -32,7 +32,13 @@ module NewRelic
             end
 
             wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new(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

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.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/rack/instrumentation.rb

@@ -13,6 +13,7 @@ module NewRelic
             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
@@ -21,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)

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

@@ -32,15 +32,19 @@ DependencyDetection.defer do
     NewRelic::Agent::Instrumentation::ActionControllerSubscriber \
       .subscribe(/^process_action.action_controller$/)
 
-    subs = %w[send_file
+    subs = %w[exist_fragment?
+      expire_fragment
+      halted_callback
+      read_fragment
+      redirect_to
       send_data
+      send_file
       send_stream
-      redirect_to
-      halted_callback
-      unpermitted_parameters]
+      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.rb

@@ -17,7 +17,6 @@ DependencyDetection.defer do
   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 Gem::Version.new(::Rdkafka::VERSION) >= Gem::Version.new('0.16.0') ||
+            (Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('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) && Gem::Version.new(::Rdkafka::VERSION) >= Gem::Version.new('0.16.0')) ||
+          (Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('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