newrelic_rpm 9.13.0 → 9.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4322e3b796a1a4656be8f68f98c18f79a4f6f86f3dd36ba1186def73a993c6db
-  data.tar.gz: e87b88f88a979bc1ff4259643081308670dd860750d12e21cfb6cd45fa3b6004
+  metadata.gz: b0ade9f1a1a36e6382100a271c5e54a2c426c27b95884a15eac8d6740dcee29b
+  data.tar.gz: 18f728d4289bfda058bd54d7d7798a33c3a43d45de83f543b86dd573ff76283e
 SHA512:
-  metadata.gz: e53d1172e55be6cf3f66f12f3926361af7485361e1e8c2e097f725241148bbbc5cb59853ce6d255a7c34871f3530424466b621b5cab467383d9e654c0c8108d4
-  data.tar.gz: b61902a91a3909760b52797c74f7ef24e5b6f5c282ffd1bfb95451585b052004323fe6c3eb9843e208dcdfdd9382684d8f01a950051e8f7d082269d2ed7134e0
+  metadata.gz: a463e150f83291e4ef1c55e23b155621694dc5cf0a709d78bf7ebd10aee7b801afaa1e76a4fd6d12858fba7806368bad7e6b5ca53bd21273f68e1f995b524edd
+  data.tar.gz: 9d0faa058f7810ce4edff5c91a57e584e1efaea99e6d4e533b2128727b0ccc7bb61dfa87ab0a82e134bce05010c7aec5ccef9b7960f72c502e68473885492434

data/CHANGELOG.md

@@ -1,16 +1,98 @@
 # New Relic Ruby Agent Release Notes
 
+## v9.14.0
+
+Version 9.14.0 adds Apache Kafka instrumentation for the rdkafka and ruby-kafka gems, introduces a configuration-based, automatic way to add custom instrumentation method tracers, correctly captures MIME type for AcionDispatch 7.0+ requests, properly handles Boolean coercion for `newrelic.yml` configuration, fixes a JRuby bug in the configuration manager, fixes a bug related to `Bundler.rubygems.installed_specs`, and fixes a bug to make the agent compatible with ViewComponent v3.15.0+.
+
+- **Feature: Add Apache Kafka instrumentation for the rdkafka and ruby-kafka gems**
+
+  The agent now has instrumentation for both the rdkafka and ruby-kafka gems. The agent will record transactions and message broker segments for produce and consume calls made using these gems. [PR#2824](https://github.com/newrelic/newrelic-ruby-agent/pull/2824) [PR#2842](https://github.com/newrelic/newrelic-ruby-agent/pull/2842)
+
+- **Feature: Add a configuration option to permit custom method tracers to be defined automatically**
+
+  A new `:automatic_custom_instrumentation_method_list` configuration parameter has been added to permit the user to define a list of fully qualified (namespaced) Ruby methods for the agent to automatically add custom instrumentation for without requiring any code modifications to be made to the classes that define the methods.
+
+  The list should be an array of `CLASS#METHOD` (for instance methods) and/or `CLASS.METHOD` (for class methods) strings.
+
+  Use fully qualified class names (using the `::` delimiter) that include any module or class namespacing.
+
+  Here is some Ruby source code that defines a `render_png` instance method for an `Image` class and a `notify` class method for a `User` class, both within a `MyCompany` module namespace:
+
+  ```
+  module MyCompany
+    class Image
+      def render_png
+        # code to render a PNG
+      end
+    end
+
+    class User
+      def self.notify
+        # code to notify users
+      end
+    end
+  end
+  ```
+
+  Given that source code, the `newrelic.yml` config file might request instrumentation for both of these methods like so:
+
+  ```
+  automatic_custom_instrumentation_method_list:
+    - MyCompany::Image#render_png
+    - MyCompany::User.notify
+  ```
+
+  That configuration example uses YAML array syntax to specify both methods. Alternatively, a comma-delimited string can be used instead:
+
+  ```
+  automatic_custom_instrumentation_method_list: 'MyCompany::Image#render_png, MyCompany::User.notify'
+  ```
+
+  Whitespace around the comma(s) in the list is optional. When configuring the agent with a list of methods via the `NEW_RELIC_AUTOMATIC_CUSTOM_INSTRUMENTATION_METHOD_LIST` environment variable, this comma-delimited string format should be used:
+
+  ```
+  export NEW_RELIC_AUTOMATIC_CUSTOM_INSTRUMENTATION_METHOD_LIST='MyCompany::Image#render_png, MyCompany::User.notify'
+  ```
+
+  [PR#2851](https://github.com/newrelic/newrelic-ruby-agent/pull/2851)
+
+- **Feature: Collect just MIME type for AcionDispatch 7.0+ requests**
+
+  Rails 7.0 [introduced changes](https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#actiondispatch-request-content-type-now-returns-content-type-header-as-it-is) to the behavior of `ActionDispatch::Request#content_type`, adding extra request-related details the agent wasn't expecting to collect. Additionally, the agent's use of `content_type ` was triggering deprecation warnings. The agent now uses `ActionDispatch::Request#media_type` to capture the MIME type. Thanks to [@internethostage](https://github.com/internethostage) for letting us know about this change. [Issue#2500](https://github.com/newrelic/newrelic-ruby-agent/issues/2500) [PR#2855](https://github.com/newrelic/newrelic-ruby-agent/pull/2855)
+
+- **Bugfix: Corrected Boolean coercion for `newrelic.yml` configuration**
+
+  Previously, any String assigned to New Relic configurations expecting a Boolean value were evaluated as `true`. This could lead to unexpected behavior. For example, setting `application_logging.enabled: 'false'` in `newrelic.yml` would incorrectly evaluate to `application_logging.enabled: true` due to the truthy nature of Strings.
+
+  Now, the agent strictly interprets Boolean configuration values. It recognizes both actual Boolean values and certain Strings/Symbols:
+  - `'true'`, `'yes'`, or `'on'` (evaluates to `true`)
+  - `'false'`, `'no'`, or `'off'` (evaluates to `false`)
+
+  Any other inputs will revert to the setting's default configuration value. [PR#2847](https://github.com/newrelic/newrelic-ruby-agent/pull/2847)
+
+- **Bugfix: JRuby not saving configuration values correctly in configuration manager**
+
+  Previously, a change made to fix a different JRuby bug caused the agent to not save configuration values correctly in the configuration manager when running on JRuby. This has been fixed. [PR#2848](https://github.com/newrelic/newrelic-ruby-agent/pull/2848)
+
+- **Bugfix: Update condition to verify Bundler.rubygems.installed_specs is available**
+
+  To address a recent Bundler deprecation warning, we started using `Bundler.rubygems.installed_specs` instead of `Bundler.rubygems.all_specs` in environments that seemed appropriate. We discovered the version constraint we used was too low. Now, rather than check the version, we check for the method using `respond_to?`. [PR#2853](https://github.com/newrelic/newrelic-ruby-agent/pull/2853)
+
+- **Bugfix: Support view_component v3.15.0+**
+
+  Previously the agent had been making use of a private API to obtain a component identifier value. This private API was dropped in v3.15.0 of view_component, resulting in errors from the New Relic Ruby agent's continued attempts to use it. Many thanks to community member [@navidemad](https://github.com/navidemad) for bringing this issue to our attention and supplying a bugfix with [PR#2870](https://github.com/newrelic/newrelic-ruby-agent/pull/2870).
+
 ## v9.13.0
 
 Version 9.13.0 enhances support for AWS Lambda functions, adds experimental OpenSearch instrumentation, updates framework detection, silences a Bundler deprecation warning, fixes Falcon dispatcher detection, fixes a bug with Redis instrumentation installation, and addresses a JRuby-specific concurrency issue.
 
 - **Feature: Enhance AWS Lambda function instrumentation**
 
-When utilized via the latest [New Relic Ruby layer for AWS Lambda](https://layers.newrelic-external.com/), the agent now offers enhanced support for AWS Lambda function instrumentation. 
-* The agent's instrumentation for AWS Lambda functions now supports distributed tracing. 
-* Web-triggered invocations are now identified as being "web"-based when an API Gateway call is involved, with support for both API Gateway versions 1.0 and 2.0. 
-* Web-based calls have the HTTP method, URI, and status code recorded. 
-* The agent now recognizes and reports on 12 separate AWS resources that are capable of triggering a Lambda function invocation: ALB, API Gateway V1, API Gateway V2, CloudFront, CloudWatch Scheduler, DynamoStreams, Firehose, Kinesis, S3, SES, SNS, and SQS. 
+When utilized via the latest [New Relic Ruby layer for AWS Lambda](https://layers.newrelic-external.com/), the agent now offers enhanced support for AWS Lambda function instrumentation.
+* The agent's instrumentation for AWS Lambda functions now supports distributed tracing.
+* Web-triggered invocations are now identified as being "web"-based when an API Gateway call is involved, with support for both API Gateway versions 1.0 and 2.0.
+* Web-based calls have the HTTP method, URI, and status code recorded.
+* The agent now recognizes and reports on 12 separate AWS resources that are capable of triggering a Lambda function invocation: ALB, API Gateway V1, API Gateway V2, CloudFront, CloudWatch Scheduler, DynamoStreams, Firehose, Kinesis, S3, SES, SNS, and SQS.
 * The type of the triggering resource and its ARN will be recorded for each resource, and for many of them, extra resource-specific attributes will be recorded as well. For example, Lambda function invocations triggered by S3 bucket activity will now result in the S3 bucket name being recorded.
 [PR#2811](https://github.com/newrelic/newrelic-ruby-agent/pull/2811)
 

data/lib/new_relic/agent/configuration/default_source.rb

@@ -35,6 +35,15 @@ module NewRelic
       end
 
       class DefaultSource
+        BOOLEAN_MAP = {
+          'true' => true,
+          'yes' => true,
+          'on' => true,
+          'false' => false,
+          'no' => false,
+          'off' => false
+        }.freeze
+
         attr_reader :defaults
 
         extend Forwardable
@@ -64,6 +73,12 @@ module NewRelic
           value_from_defaults(key, :allowlist)
         end
 
+        def self.boolean_for(key, value)
+          string_value = (value.respond_to?(:call) ? value.call : value).to_s
+
+          BOOLEAN_MAP.fetch(string_value, nil)
+        end
+
         def self.default_for(key)
           value_from_defaults(key, :default)
         end
@@ -1137,6 +1152,56 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'If `false`, custom attributes will not be sent on events.'
         },
+        :automatic_custom_instrumentation_method_list => {
+          :default => NewRelic::EMPTY_ARRAY,
+          :public => true,
+          :type => Array,
+          :allowed_from_server => false,
+          :transform => proc { |arr| NewRelic::Agent.add_automatic_method_tracers(arr) },
+          :description => <<~DESCRIPTION
+            An array of `CLASS#METHOD` (for instance methods) and/or `CLASS.METHOD` (for class methods) strings representing Ruby methods for the agent to automatically add custom instrumentation to without the need for altering any of the source code that defines the methods.
+
+            Use fully qualified class names (using the `::` delimiter) that include any module or class namespacing.
+
+            Here is some Ruby source code that defines a `render_png` instance method for an `Image` class and a `notify` class method for a `User` class, both within a `MyCompany` module namespace:
+
+            ```
+            module MyCompany
+              class Image
+                def render_png
+                  # code to render a PNG
+                end
+              end
+
+              class User
+                def self.notify
+                  # code to notify users
+                end
+              end
+            end
+            ```
+
+            Given that source code, the `newrelic.yml` config file might request instrumentation for both of these methods like so:
+
+            ```
+            automatic_custom_instrumentation_method_list:
+              - MyCompany::Image#render_png
+              - MyCompany::User.notify
+            ```
+
+            That configuration example uses YAML array syntax to specify both methods. Alternatively, a comma-delimited string can be used instead:
+
+            ```
+            automatic_custom_instrumentation_method_list: 'MyCompany::Image#render_png, MyCompany::User.notify'
+            ```
+
+            Whitespace around the comma(s) in the list is optional. When configuring the agent with a list of methods via the `NEW_RELIC_AUTOMATIC_CUSTOM_INSTRUMENTATION_METHOD_LIST` environment variable, this comma-delimited string format should be used:
+
+            ```
+            export NEW_RELIC_AUTOMATIC_CUSTOM_INSTRUMENTATION_METHOD_LIST='MyCompany::Image#render_png, MyCompany::User.notify'
+            ```
+          DESCRIPTION
+        },
         # Custom events
         :'custom_insights_events.enabled' => {
           :default => true,
@@ -1463,6 +1528,14 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'Controls auto-instrumentation of bunny at start-up. May be one of: `auto`, `prepend`, `chain`, `disabled`.'
         },
+        :'instrumentation.ruby_kafka' => {
+          :default => 'auto',
+          :public => true,
+          :type => String,
+          :dynamic_name => true,
+          :allowed_from_server => false,
+          :description => 'Controls auto-instrumentation of the ruby-kafka library at start-up. May be one of `auto`, `prepend`, `chain`, `disabled`.'
+        },
         :'instrumentation.opensearch' => {
           :default => 'auto',
           :documentation_default => 'auto',
@@ -1472,6 +1545,14 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'Controls auto-instrumentation of the opensearch-ruby library at start-up. May be one of `auto`, `prepend`, `chain`, `disabled`.'
         },
+        :'instrumentation.rdkafka' => {
+          :default => 'auto',
+          :public => true,
+          :type => String,
+          :dynamic_name => true,
+          :allowed_from_server => false,
+          :description => 'Controls auto-instrumentation of the rdkafka library at start-up. May be one of `auto`, `prepend`, `chain`, `disabled`.'
+        },
         :'instrumentation.aws_sqs' => {
           :default => 'auto',
           :public => true,
@@ -2202,7 +2283,7 @@ module NewRelic
           :description => 'Enable or disable debugging version of JavaScript agent loader for browser monitoring instrumentation.'
         },
         :'browser_monitoring.ssl_for_http' => {
-          :default => nil,
+          :default => false,
           :allow_nil => true,
           :public => false,
           :type => Boolean,

data/lib/new_relic/agent/configuration/environment_source.rb

@@ -92,7 +92,11 @@ module NewRelic
           elsif type == Symbol
             self[config_key] = value.to_sym
           elsif type == Array
-            self[config_key] = value.split(/\s*,\s*/)
+            self[config_key] = if DEFAULTS[config_key].key?(:transform)
+              DEFAULTS[config_key][:transform].call(value)
+            else
+              value.split(/\s*,\s*/)
+            end
           elsif type == NewRelic::Agent::Configuration::Boolean
             if /false|off|no/i.match?(value)
               self[config_key] = false

data/lib/new_relic/agent/configuration/manager.rb

@@ -142,6 +142,9 @@ module NewRelic
           default = enforce_allowlist(key, evaluated)
           return default if default
 
+          boolean = enforce_boolean(key, value)
+          return boolean if [true, false].include?(boolean)
+
           apply_transformations(key, evaluated)
         end
 
@@ -167,6 +170,18 @@ module NewRelic
           default
         end
 
+        def enforce_boolean(key, value)
+          type = default_source.value_from_defaults(key, :type)
+          return unless type == Boolean
+
+          bool_value = default_source.boolean_for(key, value)
+          return bool_value unless bool_value.nil?
+
+          default = default_source.default_for(key)
+          NewRelic::Agent.logger.warn "Invalid value '#{value}' for #{key}, applying default value of '#{default}'"
+          default
+        end
+
         def transform_from_default(key)
           default_source.transform_for(key)
         end
@@ -388,7 +403,7 @@ module NewRelic
           # modified. The hash really only needs to be modified for the benefit
           # of the security agent, so if JRuby is in play and the security agent
           # is not, don't attempt to modify the hash at all and return early.
-          return @cache if NewRelic::LanguageSupport.jruby? && !Agent.config[:'security.agent.enabled']
+          return new_cache if NewRelic::LanguageSupport.jruby? && !Agent.config[:'security.agent.enabled']
 
           @lock.synchronize do
             preserved = @cache.dup.select { |_k, v| DEPENDENCY_DETECTION_VALUES.include?(v) }

data/lib/new_relic/agent/database/obfuscation_helpers.rb

@@ -7,17 +7,17 @@ module NewRelic
     module Database
       module ObfuscationHelpers
         COMPONENTS_REGEX_MAP = {
-          :single_quotes => /'(?:[^']|'')*?(?:\\'.*|'(?!'))/,
-          :double_quotes => /"(?:[^"]|"")*?(?:\\".*|"(?!"))/,
-          :dollar_quotes => /(\$(?!\d)[^$]*?\$).*?(?:\1|$)/,
-          :uuids => /\{?(?:[0-9a-fA-F]\-*){32}\}?/,
-          :numeric_literals => /-?\b(?:[0-9]+\.)?[0-9]+([eE][+-]?[0-9]+)?\b/,
-          :boolean_literals => /\b(?:true|false|null)\b/i,
-          :hexadecimal_literals => /0x[0-9a-fA-F]+/,
-          :comments => /(?:#|--).*?(?=\r|\n|$)/i,
-          :multi_line_comments => /\/\*(?:[^\/]|\/[^*])*?(?:\*\/|\/\*.*)/,
-          :oracle_quoted_strings => /q'\[.*?(?:\]'|$)|q'\{.*?(?:\}'|$)|q'\<.*?(?:\>'|$)|q'\(.*?(?:\)'|$)/
-        }
+          single_quotes: /'(?:[^']|'')*?(?:\\'.*|'(?!'))/,
+          double_quotes: /"(?:[^"]|"")*?(?:\\".*|"(?!"))/,
+          dollar_quotes: /(\$(?!\d)[^$]*?\$).*?(?:\1|$)/,
+          uuids: /\{?(?:[0-9a-fA-F]-*){32}\}?/,
+          numeric_literals: /-?\b(?:[0-9]+\.)?[0-9]+([eE][+-]?[0-9]+)?\b/,
+          boolean_literals: /\b(?:true|false|null)\b/i,
+          hexadecimal_literals: /0x[0-9a-fA-F]+/,
+          comments: /(?:#|--).*?(?=\r|\n|$)/i,
+          multi_line_comments: %r{/\*.*?\*/}m,
+          oracle_quoted_strings: /q'\[.*?(?:\]'|$)|q'\{.*?(?:\}'|$)|q'<.*?(?:>'|$)|q'\(.*?(?:\)'|$)/
+        }.freeze
 
         DIALECT_COMPONENTS = {
           :fallback => COMPONENTS_REGEX_MAP.keys,

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

@@ -31,8 +31,9 @@ module NewRelic::Agent::Instrumentation
         collection: args[0][:table_name]
       )
 
-      arn = get_arn(args[0])
-      segment&.add_agent_attribute('cloud.resource_id', arn) if arn
+      # TODO: Update this when it has been decided how to handle account id for ARN
+      # 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

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

@@ -20,7 +20,7 @@ DependencyDetection.defer do
   depends_on do
     begin
       if defined?(Bundler) &&
-          ((Gem::Version.new(Bundler::VERSION) >= Gem::Version.new('2.0.0') && Bundler.rubygems.installed_specs.map(&:name).include?('newrelic-grape')) ||
+          ((Bundler.rubygems.respond_to?(:installed_specs) && Bundler.rubygems.installed_specs.map(&:name).include?('newrelic-grape')) ||
             Bundler.rubygems.all_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

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

@@ -0,0 +1,71 @@
+# 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')
+          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,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 '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')
+        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,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
+
+DependencyDetection.defer do
+  named :rdkafka
+
+  depends_on do
+    defined?(Rdkafka)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing rdkafka instrumentation')
+
+    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

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

@@ -0,0 +1,55 @@
+# 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 RubyKafka::Chain
+    def self.instrument!
+      ::Kafka::Producer.class_eval do
+        include NewRelic::Agent::Instrumentation::RubyKafka
+
+        alias_method(:produce_without_new_relic, :produce)
+
+        def produce(value, **kwargs)
+          produce_with_new_relic(value, **kwargs) do |headers|
+            kwargs[:headers] = headers
+            produce_without_new_relic(value, **kwargs)
+          end
+        end
+      end
+
+      ::Kafka::Consumer.class_eval do
+        include NewRelic::Agent::Instrumentation::RubyKafka
+
+        alias_method(:each_message_without_new_relic, :each_message)
+
+        def each_message(*args)
+          each_message_without_new_relic(*args) do |message|
+            each_message_with_new_relic(message) do
+              yield(message)
+            end
+          end
+        end
+      end
+
+      ::Kafka::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::RubyKafkaConfig
+
+        alias_method(:producer_without_new_relic, :producer)
+        alias_method(:consumer_without_new_relic, :consumer)
+
+        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
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/ruby_kafka/instrumentation.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 'new_relic/agent/messaging'
+
+module NewRelic::Agent::Instrumentation
+  module RubyKafka
+    MESSAGING_LIBRARY = 'Kafka'
+    PRODUCE = 'Produce'
+    CONSUME = 'Consume'
+
+    INSTRUMENTATION_NAME = 'ruby-kafka'
+
+    def produce_with_new_relic(value, **kwargs)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      topic_name = kwargs[: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 = kwargs[:headers] || {}
+      ::NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(headers)
+
+      NewRelic::Agent::Tracer.capture_segment_error(segment) { yield(headers) }
+    ensure
+      segment&.finish
+    end
+
+    def each_message_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:)
+      @nr_config.each do |seed_broker|
+        host = "#{seed_broker&.host}:#{seed_broker&.port}"
+        NewRelic::Agent.record_metric("MessageBroker/Kafka/Nodes/#{host}/#{action}/#{topic}", 1)
+        NewRelic::Agent.record_metric("MessageBroker/Kafka/Nodes/#{host}", 1)
+      end
+    end
+  end
+
+  module RubyKafkaConfig
+    def set_nr_config(producer_or_consumer)
+      producer_or_consumer.instance_variable_set(:@nr_config, @seed_brokers)
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# 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 RubyKafkaProducer
+    module Prepend
+      include NewRelic::Agent::Instrumentation::RubyKafka
+
+      def produce(value, **kwargs)
+        produce_with_new_relic(value, **kwargs) do |headers|
+          kwargs[:headers] = headers
+          super
+        end
+      end
+    end
+  end
+
+  module RubyKafkaConsumer
+    module Prepend
+      include NewRelic::Agent::Instrumentation::RubyKafka
+
+      def each_message(*args)
+        super do |message|
+          each_message_with_new_relic(message) do
+            yield(message)
+          end
+        end
+      end
+    end
+  end
+
+  module RubyKafkaClient
+    module Prepend
+      include NewRelic::Agent::Instrumentation::RubyKafkaConfig
+
+      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
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/ruby_kafka.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
+
+require_relative 'ruby_kafka/instrumentation'
+require_relative 'ruby_kafka/chain'
+require_relative 'ruby_kafka/prepend'
+
+DependencyDetection.defer do
+  named :'ruby_kafka'
+
+  depends_on do
+    defined?(Kafka)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ruby-kafka instrumentation')
+
+    if use_prepend?
+      prepend_instrument Kafka::Producer, NewRelic::Agent::Instrumentation::RubyKafkaProducer::Prepend
+      prepend_instrument Kafka::Consumer, NewRelic::Agent::Instrumentation::RubyKafkaConsumer::Prepend
+      prepend_instrument Kafka::Client, NewRelic::Agent::Instrumentation::RubyKafkaClient::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::RubyKafka::Chain
+    end
+  end
+end

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

@@ -11,7 +11,10 @@ module NewRelic::Agent::Instrumentation
 
       begin
         segment = NewRelic::Agent::Tracer.start_segment(
-          name: metric_name(self.class.identifier, self.class.name)
+          name: metric_name(
+            self.class.respond_to?(:identifier) ? self.class.identifier : nil,
+            self.class.name
+          )
         )
         yield
       rescue => e

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -164,9 +164,8 @@ module NewRelic
 
       def add_ssl_for_http(data)
         ssl_for_http = NewRelic::Agent.config[:'browser_monitoring.ssl_for_http']
-        unless ssl_for_http.nil?
-          data[SSL_FOR_HTTP_KEY] = ssl_for_http
-        end
+
+        data[SSL_FOR_HTTP_KEY] = ssl_for_http if ssl_for_http
       end
 
       def add_attributes(data, txn)

data/lib/new_relic/agent/messaging.rb

@@ -117,7 +117,8 @@ module NewRelic
         queue_name: nil,
         exchange_type: nil,
         reply_to: nil,
-        correlation_id: nil)
+        correlation_id: nil,
+        action: nil)
 
         state = Tracer.state
         return yield if state.current_transaction
@@ -125,12 +126,12 @@ module NewRelic
         txn = nil
 
         begin
-          txn_name = transaction_name(library, destination_type, destination_name)
+          txn_name = transaction_name(library, destination_type, destination_name, action)
 
           txn = Tracer.start_transaction(name: txn_name, category: :message)
-
           if headers
-            txn.distributed_tracer.consume_message_headers(headers, state, RABBITMQ_TRANSPORT_TYPE)
+            NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(headers, library) # to handle the new w3c headers
+            txn.distributed_tracer.consume_message_headers(headers, state, library) # to do the expected old things
             CrossAppTracing.reject_messaging_cat_headers(headers).each do |k, v|
               txn.add_agent_attribute(:"message.headers.#{k}", v, AttributeFilter::DST_NONE) unless v.nil?
             end
@@ -327,12 +328,17 @@ module NewRelic
         NewRelic::Agent.config[:'message_tracer.segment_parameters.enabled']
       end
 
-      def transaction_name(library, destination_type, destination_name)
+      def transaction_name(library, destination_type, destination_name, action = nil)
         transaction_name = Transaction::MESSAGE_PREFIX + library
         transaction_name << NewRelic::SLASH
         transaction_name << Transaction::MessageBrokerSegment::TYPES[destination_type]
         transaction_name << NewRelic::SLASH
 
+        if action == :consume
+          transaction_name << 'Consume'
+          transaction_name << NewRelic::SLASH
+        end
+
         case destination_type
         when :queue
           transaction_name << Transaction::MessageBrokerSegment::NAMED

data/lib/new_relic/agent/transaction/request_attributes.rb

@@ -24,7 +24,7 @@ module NewRelic
           @referer = referer_from_request(request)
           @accept = attribute_from_env(request, HTTP_ACCEPT_HEADER_KEY)
           @content_length = content_length_from_request(request)
-          @content_type = attribute_from_request(request, :content_type)
+          @content_type = content_type_attribute_from_request(request)
           @host = attribute_from_request(request, :host)
           @port = port_from_request(request)
           @user_agent = attribute_from_request(request, :user_agent)
@@ -127,6 +127,18 @@ module NewRelic
           end
         end
 
+        def content_type_attribute_from_request(request)
+          # Rails 7.0 changed the behavior of `content_type`. We want just the MIME type, so use `media_type` if available.
+          # https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#actiondispatch-request-content-type-now-returns-content-type-header-as-it-is
+          content_type = if request.respond_to?(:media_type)
+            :media_type
+          elsif request.respond_to?(:content_type)
+            :content_type
+          end
+
+          request.send(content_type) if content_type
+        end
+
         def attribute_from_env(request, key)
           if env = attribute_from_request(request, :env)
             env[key]

data/lib/new_relic/agent.rb

@@ -85,6 +85,10 @@ module NewRelic
     # An exception that forces an agent to stop reporting until its mongrel is restarted.
     class ForceDisconnectException < StandardError; end
 
+    # Error handling for the automated custom instrumentation tracer logic
+    class AutomaticTracerParseException < StandardError; end
+    class AutomaticTracerTraceException < StandardError; end
+
     # An exception that forces an agent to restart.
     class ForceRestartException < StandardError
       def message
@@ -109,6 +113,9 @@ module NewRelic
     # placeholder name used when we cannot determine a transaction's name
     UNKNOWN_METRIC = '(unknown)'.freeze
     LLM_FEEDBACK_MESSAGE = 'LlmFeedbackMessage'
+    # give the observed app time to load the code that automatic tracers have
+    # been configured for
+    AUTOMATIC_TRACER_MAX_ATTEMPTS = 60 # 60 = try about twice a second for 30 seconds
 
     attr_reader :error_group_callback
     attr_reader :llm_token_count_callback
@@ -163,6 +170,92 @@ module NewRelic
       end
     end
 
+    # @api private
+    def self.add_automatic_method_tracers(arr)
+      return unless arr
+      return arr if arr.respond_to?(:empty?) && arr.empty?
+
+      arr = arr.split(/\s*,\s*/) if arr.is_a?(String)
+
+      add_tracers_once_methods_are_defined(arr.dup)
+
+      arr
+    end
+
+    # spawn a thread that will attempt to establish a tracer for each of the
+    # configured methods. the thread will continue to keep trying with each
+    # tracer until one of the following happens:
+    #   - the tracer is successfully established
+    #   - the configured method string couldn't be parsed
+    #   - establishing a tracer for a successfully parsed string failed
+    #   - the maximum number of attempts has been reached
+    # the thread will only be spawned once per agent initialization, to account
+    # for configuration reloading scenarios.
+    #
+    # @api private
+    def self.add_tracers_once_methods_are_defined(notations)
+      # this class method can be invoked multiple times at agent startup, so
+      # we return asap here instead of using a traditional memoization of
+      # waiting for the method's body to finish being executed
+      if defined?(@add_tracers_once_methods_are_defined)
+        return
+      else
+        @add_tracers_once_methods_are_defined = true
+      end
+
+      Thread.new do
+        AUTOMATIC_TRACER_MAX_ATTEMPTS.times do
+          notations.delete_if { |notation| prep_tracer_for(notation) }
+
+          break if notations.empty?
+
+          sleep 0.5
+        end
+      end
+    end
+
+    # returns `true` if the notation string has either been successfully
+    # processed or raised an error during processing. returns `false` if the
+    # string seems good but the (customer) code to be traced has not yet been
+    # loaded into the Ruby VM
+    #
+    # @api private
+    def self.prep_tracer_for(fully_qualified_method_notation)
+      delimiters = fully_qualified_method_notation.scan(/\.|#/)
+      raise AutomaticTracerParseException.new("Expected exactly one '.' or '#' delimiter.") unless delimiters.size == 1
+
+      delimiter = delimiters.first
+      namespace, method_name = fully_qualified_method_notation.split(delimiter)
+      unless namespace && !namespace.empty?
+        raise AutomaticTracerParseException.new("Nothing found to the left of the #{delimiter} delimiter.")
+      end
+      unless method_name && !method_name.empty?
+        raise AutomaticTracerParseException.new("Nothing found to the right of the #{delimiter} delimiter.")
+      end
+
+      begin
+        klass = ::NewRelic::LanguageSupport.constantize(namespace)
+        return false unless klass
+
+        klass_to_trace = delimiter.eql?('.') ? klass.singleton_class : klass
+        add_or_defer_method_tracer(klass_to_trace, method_name, nil, {})
+      rescue StandardError => e
+        raise AutomaticTracerTraceException.new("#{e.class} - #{e.message}")
+      end
+
+      true
+    rescue AutomaticTracerParseException => e
+      NewRelic::Agent.logger.error('Unable to parse out a usable method name to trace. Expected a valid, fully ' \
+                                   "qualified method notation. Got: '#{fully_qualified_method_notation}'. " \
+                                   "Error: #{e.message}")
+      true
+    rescue AutomaticTracerTraceException => e
+      NewRelic::Agent.logger.error('Unable to automatically apply a tracer to method ' \
+                                   "'#{fully_qualified_method_notation}'. Error: #{e.message}")
+      true
+    end
+
+    # @api private
     def add_deferred_method_tracers_now
       @tracer_lock.synchronize do
         @tracer_queue.each do |receiver, method_name, metric_name, options|

data/lib/new_relic/control/frameworks/rails4.rb

@@ -9,7 +9,7 @@ module NewRelic
     module Frameworks
       class Rails4 < NewRelic::Control::Frameworks::Rails3
         def rails_gem_list
-          if Gem::Version.new(Bundler::VERSION) >= Gem::Version.new('2.0.0')
+          if Bundler.rubygems.respond_to?(:installed_specs)
             Bundler.rubygems.installed_specs.map { |gem| "#{gem.name} (#{gem.version})" }
           else
             Bundler.rubygems.all_specs.map { |gem| "#{gem.name} (#{gem.version})" }

data/lib/new_relic/environment_report.rb

@@ -44,7 +44,7 @@ module NewRelic
     ####################################
     report_on('Gems') do
       begin
-        if Gem::Version.new(Bundler::VERSION) >= Gem::Version.new('2.0.0')
+        if Bundler.rubygems.respond_to?(:installed_specs)
           Bundler.rubygems.installed_specs.map { |gem| "#{gem.name}(#{gem.version})" }
         else
           Bundler.rubygems.all_specs.map { |gem| "#{gem.name}(#{gem.version})" }

data/lib/new_relic/language_support.rb

@@ -90,7 +90,7 @@ module NewRelic
     def bundled_gem?(gem_name)
       return false unless defined?(Bundler)
 
-      if Gem::Version.new(Bundler::VERSION) >= Gem::Version.new('2.0.0')
+      if Bundler.rubygems.respond_to?(:installed_specs)
         Bundler.rubygems.installed_specs.map(&:name).include?(gem_name)
       else
         Bundler.rubygems.all_specs.map(&:name).include?(gem_name)

data/lib/new_relic/version.rb

@@ -6,7 +6,7 @@
 module NewRelic
   module VERSION # :nodoc:
     MAJOR = 9
-    MINOR = 13
+    MINOR = 14
     TINY = 0
 
     STRING = "#{MAJOR}.#{MINOR}.#{TINY}"

data/newrelic.yml

@@ -113,6 +113,53 @@ common: &default_settings
   # Specifies a path to the audit log file (including the filename).
   # audit_log.path: log/newrelic_audit.log
 
+  # An array of CLASS#METHOD (for instance methods) and/or CLASS.METHOD (for class
+  # methods) strings representing Ruby methods for the agent to automatically add
+  # custom instrumentation to without the need for altering any of the source code
+  # that defines the methods.
+  #
+  # Use fully qualified class names (using the :: delimiter) that include any
+  # module or class namespacing.
+  #
+  # Here is some Ruby source code that defines a render_png instance method for an
+  # Image class and a notify class method for a User class, both within a
+  # MyCompany module namespace:
+  # 
+  # module MyCompany
+  #   class Image
+  #     def render_png
+  #       # code to render a PNG
+  #     end
+  #   end
+  #
+  #   class User
+  #     def self.notify
+  #       # code to notify users
+  #     end
+  #   end
+  # end
+  # 
+  # Given that source code, the newrelic.yml config file might request
+  # instrumentation for both of these methods like so:
+  # 
+  # automatic_custom_instrumentation_method_list:
+  # - MyCompany::Image#render_png
+  # - MyCompany::User.notify
+  #
+  # That configuration example uses YAML array syntax to specify both methods.
+  # Alternatively, a comma-delimited string can be used instead:
+  # 
+  # automatic_custom_instrumentation_method_list: 'MyCompany::Image#render_png, MyCompany::User.notify'
+  # 
+  # Whitespace around the comma(s) in the list is optional. When configuring the
+  # agent with a list of methods via the
+  # NEW_RELIC_AUTOMATIC_CUSTOM_INSTRUMENTATION_METHOD_LIST environment variable,
+  # this comma-delimited string format should be used:
+  # 
+  # export NEW_RELIC_AUTOMATIC_CUSTOM_INSTRUMENTATION_METHOD_LIST='MyCompany::Image#render_png, MyCompany::User.notify'
+  # 
+  # automatic_custom_instrumentation_method_list: []
+
   # Specify a list of constants that should prevent the agent from starting
   # automatically. Separate individual constants with a comma ,. For example,
   # "Rails::Console,UninstrumentedBackgroundJob".
@@ -535,6 +582,10 @@ common: &default_settings
   # prepend, chain, disabled.
   # instrumentation.rake: auto
 
+  # Controls auto-instrumentation of the rdkafka library at start-up. May be one
+  # of auto, prepend, chain, disabled.
+  # instrumentation.rdkafka: auto
+
   # Controls auto-instrumentation of Redis at start-up. May be one of: auto,
   # prepend, chain, disabled.
   # instrumentation.redis: auto
@@ -547,6 +598,10 @@ common: &default_settings
   # prepend, chain, disabled.
   # instrumentation.roda: auto
 
+  # Controls auto-instrumentation of the ruby-kafka library at start-up. May be
+  # one of auto, prepend, chain, disabled.
+  # instrumentation.ruby_kafka: auto
+
   # Controls auto-instrumentation of the ruby-openai gem at start-up. May be one
   # of: auto, prepend, chain, disabled. Defaults to disabled in high security
   # mode.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 9.13.0
+  version: 9.14.0
 platform: ruby
 authors:
 - Tanna McClure
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-22 00:00:00.000000000 Z
+date: 2024-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -509,6 +509,10 @@ files:
 - lib/new_relic/agent/instrumentation/rake/chain.rb
 - lib/new_relic/agent/instrumentation/rake/instrumentation.rb
 - lib/new_relic/agent/instrumentation/rake/prepend.rb
+- lib/new_relic/agent/instrumentation/rdkafka.rb
+- lib/new_relic/agent/instrumentation/rdkafka/chain.rb
+- lib/new_relic/agent/instrumentation/rdkafka/instrumentation.rb
+- lib/new_relic/agent/instrumentation/rdkafka/prepend.rb
 - lib/new_relic/agent/instrumentation/redis.rb
 - lib/new_relic/agent/instrumentation/redis/chain.rb
 - lib/new_relic/agent/instrumentation/redis/cluster_middleware.rb
@@ -527,6 +531,10 @@ files:
 - lib/new_relic/agent/instrumentation/roda/instrumentation.rb
 - lib/new_relic/agent/instrumentation/roda/prepend.rb
 - lib/new_relic/agent/instrumentation/roda/roda_transaction_namer.rb
+- lib/new_relic/agent/instrumentation/ruby_kafka.rb
+- lib/new_relic/agent/instrumentation/ruby_kafka/chain.rb
+- lib/new_relic/agent/instrumentation/ruby_kafka/instrumentation.rb
+- lib/new_relic/agent/instrumentation/ruby_kafka/prepend.rb
 - lib/new_relic/agent/instrumentation/ruby_openai.rb
 - lib/new_relic/agent/instrumentation/ruby_openai/chain.rb
 - lib/new_relic/agent/instrumentation/ruby_openai/instrumentation.rb
@@ -770,7 +778,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.16
 signing_key: 
 specification_version: 4
 summary: New Relic Ruby Agent