newrelic_rpm 9.7.0 → 9.8.0

data/lib/new_relic/agent/llm/chat_completion_summary.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 'response_headers'
+
+module NewRelic
+  module Agent
+    module Llm
+      class ChatCompletionSummary < LlmEvent
+        include ResponseHeaders
+
+        ATTRIBUTES = %i[request_max_tokens response_number_of_messages
+          request_model response_choices_finish_reason request_temperature
+          duration error]
+        ATTRIBUTE_NAME_EXCEPTIONS = {
+          response_number_of_messages: 'response.number_of_messages',
+          request_model: 'request.model',
+          response_choices_finish_reason: 'response.choices.finish_reason',
+          request_temperature: 'request.temperature'
+        }
+        ERROR_COMPLETION_ID = 'completion_id'
+        EVENT_NAME = 'LlmChatCompletionSummary'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def attributes
+          LlmEvent::ATTRIBUTES + ResponseHeaders::ATTRIBUTES + ATTRIBUTES
+        end
+
+        def attribute_name_exceptions
+          # TODO: OLD RUBIES < 2.6
+          # Hash#merge accepts multiple arguments in 2.6
+          # Remove condition once support for Ruby <2.6 is dropped
+          if RUBY_VERSION >= '2.6.0'
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS, ATTRIBUTE_NAME_EXCEPTIONS)
+          else
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS).merge(ATTRIBUTE_NAME_EXCEPTIONS)
+          end
+        end
+
+        def event_name
+          EVENT_NAME
+        end
+
+        def error_attributes(exception)
+          attrs = {ERROR_COMPLETION_ID => id}
+
+          error_attributes_from_response(exception, attrs)
+        end
+
+        private
+
+        def error_attributes_from_response(exception, attrs)
+          return attrs unless exception.respond_to?(:response)
+
+          attrs[ERROR_ATTRIBUTE_STATUS_CODE] = exception.response.dig(:status)
+          attrs[ERROR_ATTRIBUTE_CODE] = exception.response.dig(:body, ERROR_STRING, CODE_STRING)
+          attrs[ERROR_ATTRIBUTE_PARAM] = exception.response.dig(:body, ERROR_STRING, PARAM_STRING)
+
+          attrs
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/embedding.rb

@@ -0,0 +1,60 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module Llm
+      class Embedding < LlmEvent
+        include ResponseHeaders
+
+        ATTRIBUTES = %i[input request_model token_count duration error].freeze
+        ATTRIBUTE_NAME_EXCEPTIONS = {
+          request_model: 'request.model'
+        }.freeze
+        ERROR_EMBEDDING_ID = 'embedding_id'
+        EVENT_NAME = 'LlmEmbedding'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def attributes
+          LlmEvent::ATTRIBUTES + ResponseHeaders::ATTRIBUTES + ATTRIBUTES
+        end
+
+        def attribute_name_exceptions
+          # TODO: OLD RUBIES < 2.6
+          # Hash#merge accepts multiple arguments in 2.6
+          # Remove condition once support for Ruby <2.6 is dropped
+          if RUBY_VERSION >= '2.6.0'
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS, ATTRIBUTE_NAME_EXCEPTIONS)
+          else
+            LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS).merge(ATTRIBUTE_NAME_EXCEPTIONS)
+          end
+        end
+
+        def event_name
+          EVENT_NAME
+        end
+
+        def error_attributes(exception)
+          attrs = {}
+          attrs[ERROR_EMBEDDING_ID] = id
+
+          error_attributes_from_response(exception, attrs)
+        end
+
+        private
+
+        def error_attributes_from_response(exception, attrs)
+          return attrs unless exception.respond_to?(:response)
+
+          attrs[ERROR_ATTRIBUTE_STATUS_CODE] = exception.response.dig(:status)
+          attrs[ERROR_ATTRIBUTE_CODE] = exception.response.dig(:body, ERROR_STRING, CODE_STRING)
+          attrs[ERROR_ATTRIBUTE_PARAM] = exception.response.dig(:body, ERROR_STRING, PARAM_STRING)
+
+          attrs
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/llm_event.rb

@@ -0,0 +1,95 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module Llm
+      class LlmEvent
+        # Every subclass must define its own ATTRIBUTES constant, an array of symbols representing
+        # that class's unique attributes
+        ATTRIBUTES = %i[id request_id span_id trace_id response_model vendor
+          ingest_source metadata]
+        # These attributes should not be passed as arguments to initialize and will be set by the agent
+        AGENT_DEFINED_ATTRIBUTES = %i[span_id trace_id ingest_source]
+        # Some attributes have names that can't be written as symbols used for metaprogramming.
+        # The ATTRIBUTE_NAME_EXCEPTIONS hash should use the symbolized version of the name as the key
+        # and the string version expected by the UI as the value.
+        ATTRIBUTE_NAME_EXCEPTIONS = {response_model: 'response.model'}
+        INGEST_SOURCE = 'Ruby'
+        ERROR_ATTRIBUTE_STATUS_CODE = 'http.statusCode'
+        ERROR_ATTRIBUTE_CODE = 'error.code'
+        ERROR_ATTRIBUTE_PARAM = 'error.param'
+        ERROR_STRING = 'error'
+        CODE_STRING = 'code'
+        PARAM_STRING = 'param'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def self.set_llm_agent_attribute_on_transaction
+          NewRelic::Agent::Transaction.add_agent_attribute(:llm, true, NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS)
+        end
+
+        # This initialize method is used for all subclasses.
+        # It leverages the subclass's `attributes` method to iterate through
+        # all the attributes for that subclass.
+        # It assigns instance variables for all arguments passed to the method.
+        # It also assigns agent-defined attributes.
+        def initialize(opts = {})
+          (attributes - AGENT_DEFINED_ATTRIBUTES).each do |attr|
+            instance_variable_set(:"@#{attr}", opts[attr]) if opts.key?(attr)
+          end
+
+          @id = id || NewRelic::Agent::GuidGenerator.generate_guid
+          @span_id = NewRelic::Agent::Tracer.current_span_id
+          @trace_id = NewRelic::Agent::Tracer.current_trace_id
+          @ingest_source = INGEST_SOURCE
+        end
+
+        # All subclasses use event_attributes to get a full hash of all
+        # attributes and their values
+        def event_attributes
+          attributes_hash = attributes.each_with_object({}) do |attr, hash|
+            hash[replace_attr_with_string(attr)] = instance_variable_get(:"@#{attr}")
+          end
+          attributes_hash.merge!(metadata) && attributes_hash.delete(:metadata) if !metadata.nil?
+
+          attributes_hash
+        end
+
+        # Subclasses define an attributes method to concatenate attributes
+        # defined across their ancestors and other modules
+        def attributes
+          ATTRIBUTES
+        end
+
+        # Subclasses that record events will override this method
+        def event_name
+        end
+
+        # Some attribute names include periods, which aren't valid values for
+        # Ruby method names. This method returns a Hash with the key as the
+        # Ruby symbolized version of the attribute and the value as the
+        # period-delimited string expected upstream.
+        def attribute_name_exceptions
+          ATTRIBUTE_NAME_EXCEPTIONS
+        end
+
+        def record
+          NewRelic::Agent.record_custom_event(event_name, event_attributes)
+        end
+
+        # Subclasses that add attributes to noticed errors will override this method
+        def error_attributes(exception)
+          NewRelic::EMPTY_HASH
+        end
+
+        private
+
+        def replace_attr_with_string(attr)
+          attribute_name_exceptions.fetch(attr, attr)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm/response_headers.rb

@@ -0,0 +1,80 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module Llm
+      module ResponseHeaders
+        ATTRIBUTES = %i[response_organization llm_version ratelimit_limit_requests
+          ratelimit_limit_tokens ratelimit_remaining_requests
+          ratelimit_remaining_tokens ratelimit_reset_requests
+          ratelimit_reset_tokens ratelimit_limit_tokens_usage_based
+          ratelimit_reset_tokens_usage_based
+          ratelimit_remaining_tokens_usage_based].freeze
+
+        ATTRIBUTE_NAME_EXCEPTIONS = {
+          response_organization: 'response.organization',
+          llm_version: 'response.headers.llmVersion',
+          ratelimit_limit_requests: 'response.headers.ratelimitLimitRequests',
+          ratelimit_limit_tokens: 'response.headers.ratelimitLimitTokens',
+          ratelimit_remaining_requests: 'response.headers.ratelimitRemainingRequests',
+          ratelimit_remaining_tokens: 'response.headers.ratelimitRemainingTokens',
+          ratelimit_reset_requests: 'response.headers.ratelimitResetRequests',
+          ratelimit_reset_tokens: 'response.headers.ratelimitResetTokens',
+          ratelimit_limit_tokens_usage_based: 'response.headers.ratelimitLimitTokensUsageBased',
+          ratelimit_reset_tokens_usage_based: 'response.headers.ratelimitResetTokensUsageBased',
+          ratelimit_remaining_tokens_usage_based: 'response.headers.ratelimitRemainingTokensUsageBased'
+        }.freeze
+
+        OPENAI_ORGANIZATION = 'openai-organization'
+        OPENAI_VERSION = 'openai-version'
+        X_RATELIMIT_LIMIT_REQUESTS = 'x-ratelimit-limit-requests'
+        X_RATELIMIT_LIMIT_TOKENS = 'x-ratelimit-limit-tokens'
+        X_RATELIMIT_REMAINING_REQUESTS = 'x-ratelimit-remaining-requests'
+        X_RATELIMIT_REMAINING_TOKENS = 'x-ratelimit-remaining-tokens'
+        X_RATELIMIT_RESET_REQUESTS = 'x-ratelimit-reset-requests'
+        X_RATELIMIT_RESET_TOKENS = 'x-ratelimit-reset-tokens'
+        X_RATELIMIT_LIMIT_TOKENS_USAGE_BASED = 'x-ratelimit-limit-tokens-usage-based'
+        X_RATELIMIT_RESET_TOKENS_USAGE_BASED = 'x-ratelimit-reset-tokens-usage-based'
+        X_RATELIMIT_REMAINING_TOKENS_USAGE_BASED = 'x-ratelimit-remaining-tokens-usage-based'
+        X_REQUEST_ID = 'x-request-id'
+
+        attr_accessor(*ATTRIBUTES)
+
+        # Headers is a hash of Net::HTTP response headers
+        def populate_openai_response_headers(headers)
+          # Embedding, ChatCompletionSummary, and ChatCompletionMessage all need
+          # request_id, so it's defined in LlmEvent. ChatCompletionMessage
+          # adds the attribute via ChatCompletionSummary.
+          self.request_id = headers[X_REQUEST_ID]&.first
+          self.response_organization = headers[OPENAI_ORGANIZATION]&.first
+          self.llm_version = headers[OPENAI_VERSION]&.first
+          self.ratelimit_limit_requests = headers[X_RATELIMIT_LIMIT_REQUESTS]&.first.to_i
+          self.ratelimit_limit_tokens = headers[X_RATELIMIT_LIMIT_TOKENS]&.first.to_i
+          remaining_headers(headers)
+          reset_headers(headers)
+          tokens_usage_based_headers(headers)
+        end
+
+        private
+
+        def remaining_headers(headers)
+          self.ratelimit_remaining_requests = headers[X_RATELIMIT_REMAINING_REQUESTS]&.first.to_i
+          self.ratelimit_remaining_tokens = headers[X_RATELIMIT_REMAINING_TOKENS]&.first.to_i
+        end
+
+        def reset_headers(headers)
+          self.ratelimit_reset_requests = headers[X_RATELIMIT_RESET_REQUESTS]&.first
+          self.ratelimit_reset_tokens = headers[X_RATELIMIT_RESET_TOKENS]&.first
+        end
+
+        def tokens_usage_based_headers(headers)
+          self.ratelimit_limit_tokens_usage_based = headers[X_RATELIMIT_LIMIT_TOKENS_USAGE_BASED]&.first.to_i
+          self.ratelimit_reset_tokens_usage_based = headers[X_RATELIMIT_RESET_TOKENS_USAGE_BASED]&.first
+          self.ratelimit_remaining_tokens_usage_based = headers[X_RATELIMIT_REMAINING_TOKENS_USAGE_BASED]&.first.to_i
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/llm.rb

@@ -0,0 +1,49 @@
+# 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 'llm/llm_event'
+require_relative 'llm/chat_completion_message'
+require_relative 'llm/chat_completion_summary'
+require_relative 'llm/embedding'
+require_relative 'llm/response_headers'
+
+module NewRelic
+  module Agent
+    class LLM
+      INPUT = 'input'
+      CONTENT = 'content'
+      SEGMENT_PATTERN = %r{Llm/.+/OpenAI/.+}.freeze
+
+      def self.instrumentation_enabled?
+        NewRelic::Agent.config[:'ai_monitoring.enabled']
+      end
+
+      # LLM content-related attributes are exempt from the 4095 byte limit
+      def self.exempt_event_attribute?(type, key)
+        return false unless instrumentation_enabled?
+
+        (type == NewRelic::Agent::Llm::Embedding::EVENT_NAME && key == INPUT) ||
+          (type == NewRelic::Agent::Llm::ChatCompletionMessage::EVENT_NAME && key == CONTENT)
+      end
+
+      def self.openai?
+        @openai ||= %i[prepend chain].include?(NewRelic::Agent.config[:'instrumentation.ruby_openai']) &&
+          NewRelic::Agent.config[:'ai_monitoring.enabled']
+      end
+
+      # Used in NetHTTP instrumentation
+      def self.openai_parent?(segment)
+        return false unless openai?
+
+        segment&.parent&.name&.match?(SEGMENT_PATTERN)
+      end
+
+      def self.populate_openai_response_headers(response, parent)
+        return unless parent.instance_variable_defined?(:@llm_event)
+
+        parent.llm_event.populate_openai_response_headers(response.to_hash)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/threading/agent_thread.rb

@@ -9,8 +9,7 @@ module NewRelic
         def self.create(label, &blk)
           ::NewRelic::Agent.logger.debug("Creating AgentThread: #{label}")
           wrapped_blk = proc do
-            if ::Thread.current[:newrelic_tracer_state] && Thread.current[:newrelic_tracer_state].current_transaction
-              txn = ::Thread.current[:newrelic_tracer_state].current_transaction
+            if (txn = ::NewRelic::ThreadLocalStorage[:newrelic_tracer_state]&.current_transaction)
               ::NewRelic::Agent.logger.warn("AgentThread created with current transaction #{txn.best_name}")
             end
             begin

data/lib/new_relic/agent/tracer.rb

@@ -392,11 +392,11 @@ module NewRelic
         #
         # If ever exposed, this requires additional synchronization
         def state_for(thread)
-          state = thread[:newrelic_tracer_state]
+          state = ThreadLocalStorage.get(thread, :newrelic_tracer_state)
 
           if state.nil?
             state = Tracer::State.new
-            thread[:newrelic_tracer_state] = state
+            ThreadLocalStorage.set(thread, :newrelic_tracer_state, state)
           end
 
           state
@@ -405,7 +405,7 @@ module NewRelic
         alias_method :tl_state_for, :state_for
 
         def clear_state
-          Thread.current[:newrelic_tracer_state] = nil
+          ThreadLocalStorage[:newrelic_tracer_state] = nil
         end
 
         alias_method :tl_clear, :clear_state
@@ -420,12 +420,12 @@ module NewRelic
 
         def thread_block_with_current_transaction(segment_name: nil, parent: nil, &block)
           parent ||= current_segment
-          current_txn = ::Thread.current[:newrelic_tracer_state]&.current_transaction if ::Thread.current[:newrelic_tracer_state]&.is_execution_traced?
+          current_txn = ThreadLocalStorage[:newrelic_tracer_state]&.current_transaction if ThreadLocalStorage[:newrelic_tracer_state]&.is_execution_traced?
           proc do |*args|
             begin
               if current_txn && !current_txn.finished?
                 NewRelic::Agent::Tracer.state.current_transaction = current_txn
-                ::Thread.current[:newrelic_thread_span_parent] = parent
+                ThreadLocalStorage[:newrelic_thread_span_parent] = parent
                 current_txn.async = true
                 segment_name = "#{segment_name}/Thread#{::Thread.current.object_id}/Fiber#{::Fiber.current.object_id}" if NewRelic::Agent.config[:'thread_ids_enabled']
                 segment = NewRelic::Agent::Tracer.start_segment(name: segment_name, parent: parent) if segment_name

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

@@ -20,7 +20,7 @@ module NewRelic
         # calculation in all other cases.
         #
         attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_segment_key
-        attr_accessor :name, :parent, :children_time, :transaction, :transaction_name
+        attr_accessor :name, :parent, :children_time, :transaction, :transaction_name, :llm_event
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 

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

@@ -41,11 +41,11 @@ module NewRelic
 
         def thread_starting_span
           # if the previous current segment was in another thread, use the thread local parent
-          if ::Thread.current[:newrelic_thread_span_parent] &&
+          if ThreadLocalStorage[:newrelic_thread_span_parent] &&
               current_segment &&
               current_segment.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key
 
-            ::Thread.current[:newrelic_thread_span_parent]
+            ThreadLocalStorage[:newrelic_thread_span_parent]
           end
         end
 

data/lib/new_relic/agent.rb

@@ -31,6 +31,7 @@ module NewRelic
     require 'new_relic/noticed_error'
     require 'new_relic/agent/noticeable_error'
     require 'new_relic/supportability_helper'
+    require 'new_relic/thread_local_storage'
 
     require 'new_relic/agent/encoding_normalizer'
     require 'new_relic/agent/stats'
@@ -62,6 +63,7 @@ module NewRelic
     require 'new_relic/agent/attribute_processing'
     require 'new_relic/agent/linking_metadata'
     require 'new_relic/agent/local_log_decorator'
+    require 'new_relic/agent/llm'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -105,11 +107,14 @@ module NewRelic
 
     # placeholder name used when we cannot determine a transaction's name
     UNKNOWN_METRIC = '(unknown)'.freeze
+    LLM_FEEDBACK_MESSAGE = 'LlmFeedbackMessage'
 
     attr_reader :error_group_callback
+    attr_reader :llm_token_count_callback
 
     @agent = nil
     @error_group_callback = nil
+    @llm_token_count_callback = nil
     @logger = nil
     @tracer_lock = Mutex.new
     @tracer_queue = []
@@ -387,6 +392,92 @@ module NewRelic
       nil
     end
 
+    # Records user feedback events for LLM applications. This API must pass
+    # the current trace id as a parameter, which can be obtained using:
+    #
+    #   NewRelic::Agent::Tracer.current_trace_id
+    #
+    # @param [String] ID of the trace where the chat completion(s) related
+    #   to the feedback occurred.
+    #
+    # @param [String or Integer] Rating provided by an end user
+    #   (ex: “Good", "Bad”, 1, 2, 5, 8, 10).
+    #
+    # @param [optional, String] Category of the feedback as provided by the
+    #   end user (ex: “informative”, “inaccurate”).
+    #
+    # @param start_time [optional, String] Freeform text feedback from an
+    #   end user.
+    #
+    # @param [optional, Hash] Set of key-value pairs to store any other
+    #   desired data to submit with the feedback event.
+    #
+    # @api public
+    #
+    def record_llm_feedback_event(trace_id:,
+      rating:,
+      category: nil,
+      message: nil,
+      metadata: NewRelic::EMPTY_HASH)
+
+      record_api_supportability_metric(:record_llm_feedback_event)
+      unless NewRelic::Agent.config[:'distributed_tracing.enabled']
+        return NewRelic::Agent.logger.error('Distributed tracing must be enabled to record LLM feedback')
+      end
+
+      feedback_message_event = {
+        'trace_id': trace_id,
+        'rating': rating,
+        'category': category,
+        'message': message,
+        'id': NewRelic::Agent::GuidGenerator.generate_guid,
+        'ingest_source': NewRelic::Agent::Llm::LlmEvent::INGEST_SOURCE
+      }
+      feedback_message_event.merge!(metadata) unless metadata.empty?
+
+      NewRelic::Agent.record_custom_event(LLM_FEEDBACK_MESSAGE, feedback_message_event)
+    rescue ArgumentError
+      raise
+    rescue => exception
+      NewRelic::Agent.logger.error('record_llm_feedback_event', exception)
+    end
+
+    # @!endgroup
+
+    # @!group LLM callbacks
+
+    # Set a callback proc for calculating `token_count` attributes for
+    # LlmEmbedding and LlmChatCompletionMessage events
+    #
+    # @param callback_proc [Proc] the callback proc
+    #
+    # This method should be called only once to set a callback for
+    # use with all LLM token calculations. If it is called multiple times, each
+    # new callback will replace the old one.
+    #
+    # The proc will be called with a single hash as its input argument and
+    # must return an Integer representing the number of tokens used for that
+    # particular prompt, completion message, or embedding. Values less than or
+    # equal to 0 will not be attached to an event.
+    #
+    # The hash has the following keys:
+    #
+    # :model => [String] The name of the LLM model
+    # :content => [String] The message content or prompt
+    #
+    # @api public
+    #
+    def set_llm_token_count_callback(callback_proc)
+      unless callback_proc.is_a?(Proc)
+        NewRelic::Agent.logger.error("#{self}.#{__method__}: expected an argument of type Proc, " \
+                                     "got #{callback_proc.class}")
+        return
+      end
+
+      record_api_supportability_metric(:set_llm_token_count_callback)
+      @llm_token_count_callback = callback_proc
+    end
+
     # @!endgroup
 
     # @!group Manual agent configuration and startup/shutdown

data/lib/new_relic/rack/browser_monitoring.rb

@@ -23,8 +23,8 @@ module NewRelic
       CONTENT_TYPE = 'Content-Type'.freeze
       CONTENT_DISPOSITION = 'Content-Disposition'.freeze
       CONTENT_LENGTH = 'Content-Length'.freeze
-      ATTACHMENT = 'attachment'.freeze
-      TEXT_HTML = 'text/html'.freeze
+      ATTACHMENT = /attachment/.freeze
+      TEXT_HTML = %r{text/html}.freeze
 
       BODY_START = '<body'.freeze
       HEAD_START = '<head'.freeze
@@ -65,6 +65,10 @@ module NewRelic
           html?(headers) &&
           !attachment?(headers) &&
           !streaming?(env, headers)
+      rescue StandardError => e
+        NewRelic::Agent.logger.error('RUM instrumentation applicability check failed on exception:' \
+                                     "#{e.class} - #{e.message}")
+        false
       end
 
       private
@@ -100,11 +104,11 @@ module NewRelic
 
       def html?(headers)
         # needs else branch coverage
-        headers[CONTENT_TYPE] && headers[CONTENT_TYPE].include?(TEXT_HTML) # rubocop:disable Style/SafeNavigation
+        headers[CONTENT_TYPE]&.match?(TEXT_HTML)
       end
 
       def attachment?(headers)
-        headers[CONTENT_DISPOSITION]&.include?(ATTACHMENT)
+        headers[CONTENT_DISPOSITION]&.match?(ATTACHMENT)
       end
 
       def streaming?(env, headers)

data/lib/new_relic/supportability_helper.rb

@@ -43,9 +43,11 @@ module NewRelic
       :process_response_metadata,
       :record_custom_event,
       :record_metric,
+      :record_llm_feedback_event,
       :recording_web_transaction?,
       :require_test_helper,
       :set_error_group_callback,
+      :set_llm_token_count_callback,
       :set_segment_callback,
       :set_sql_obfuscator,
       :set_transaction_name,

data/lib/new_relic/thread_local_storage.rb

@@ -0,0 +1,31 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module ThreadLocalStorage
+    def self.get(thread, key)
+      if Agent.config[:thread_local_tracer_state]
+        thread.thread_variable_get(key)
+      else
+        thread[key]
+      end
+    end
+
+    def self.set(thread, key, value)
+      if Agent.config[:thread_local_tracer_state]
+        thread.thread_variable_set(key, value)
+      else
+        thread[key] = value
+      end
+    end
+
+    def self.[](key)
+      get(::Thread.current, key)
+    end
+
+    def self.[]=(key, value)
+      set(::Thread.current, key, value)
+    end
+  end
+end

data/lib/new_relic/version.rb

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

data/lib/tasks/instrumentation_generator/instrumentation.thor

@@ -82,7 +82,7 @@ class Instrumentation < Thor
     insert_into_file(
       DEFAULT_SOURCE_LOCATION,
       config_block(name.downcase),
-      after: ":description => 'Controls auto-instrumentation of bunny at start-up.  May be one of [auto|prepend|chain|disabled].'
+      after: ":description => 'Controls auto-instrumentation of bunny at start-up. May be one of: `auto`, `prepend`, `chain`, `disabled`.'
         },\n"
     )
   end

data/lib/tasks/instrumentation_generator/templates/chain.tt

@@ -9,7 +9,6 @@ module NewRelic::Agent::Instrumentation
         include NewRelic::Agent::Instrumentation::<%= @class_name %>
 
         alias_method(:<%= @method.downcase %>_without_new_relic, :<%= @method.downcase %>)
-        alias_method(:<%= @method.downcase %>, :<%= @method.downcase %>_with_new_relic)
 
         def <%= @method.downcase %><%= "(#{@args})" unless @args.empty? %>
           <%= @method.downcase %>_with_new_relic<%= "(#{@args})" unless @args.empty? %> do

data/lib/tasks/instrumentation_generator/templates/chain_method.tt

@@ -1,5 +1,4 @@
 alias_method(:<%= @method.downcase %>_without_new_relic, :<%= @method.downcase %>)
-alias_method(:<%= @method.downcase %>, :<%= @method.downcase %>_with_new_relic)
 
 def <%= @method.downcase %><%= "(#{@args})" unless @args.empty? %>
   <%= @method.downcase %>_with_new_relic<%= "(#{@args})" unless @args.empty? %> do