newrelic_rpm 9.1.0 → 9.21.0

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

@@ -14,7 +14,7 @@ module NewRelic::Agent::Instrumentation
           alias_method(:initialize_without_new_relic, :initialize)
 
           def initialize(*args, &block)
-            traced_block = add_thread_tracing(*args, &block)
+            traced_block = add_thread_tracing(&block)
             initialize_with_newrelic_tracing { initialize_without_new_relic(*args, &traced_block) }
           end
         end

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

@@ -16,11 +16,7 @@ module NewRelic
         def add_thread_tracing(*args, &block)
           return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
 
-          NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-            *args,
-            segment_name: 'Ruby/Thread',
-            &block
-          )
+          NewRelic::Agent::Tracer.thread_block_with_current_transaction(&block)
         end
       end
     end

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

@@ -12,7 +12,7 @@ module NewRelic
           include NewRelic::Agent::Instrumentation::MonitoredThread
 
           def initialize(*args, &block)
-            traced_block = add_thread_tracing(*args, &block)
+            traced_block = add_thread_tracing(&block)
             initialize_with_newrelic_tracing { super(*args, &traced_block) }
           end
         end

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

@@ -9,8 +9,6 @@ DependencyDetection.defer do
   named :thread
 
   executes do
-    NewRelic::Agent.logger.info('Installing Thread Instrumentation')
-
     if use_prepend?
       prepend_instrument Thread, NewRelic::Agent::Instrumentation::MonitoredThread::Prepend
     else

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

@@ -6,6 +6,8 @@ module NewRelic
   module Agent
     module Instrumentation
       module Tilt
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
         def metric_name(klass, file)
           "View/#{klass}/#{file}/Rendering"
         end
@@ -21,6 +23,8 @@ module NewRelic
         end
 
         def render_with_tracing(*args, &block)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           begin
             finishable = Tracer.start_segment(
               name: metric_name(self.class, create_filename_for_metric(self.file))

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

@@ -11,10 +11,6 @@ DependencyDetection.defer do
 
   depends_on { defined?(Tilt) }
 
-  executes do
-    NewRelic::Agent.logger.info('Installing Tilt instrumentation')
-  end
-
   executes do
     if use_prepend?
       prepend_instrument Tilt::Template, NewRelic::Agent::Instrumentation::Tilt::Prepend

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

@@ -8,11 +8,11 @@ module NewRelic
       module Typhoeus
         HYDRA_SEGMENT_NAME = 'External/Multiple/Typhoeus::Hydra/run'
         NOTICEABLE_ERROR_CLASS = 'Typhoeus::Errors::TyphoeusError'
-
-        EARLIEST_VERSION = Gem::Version.new('0.5.3')
+        EARLIEST_VERSION = '0.5.3'
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
         def self.is_supported_version?
-          Gem::Version.new(::Typhoeus::VERSION) >= EARLIEST_VERSION
+          NewRelic::Helper.version_satisfied?(::Typhoeus::VERSION, '>=', EARLIEST_VERSION)
         end
 
         def self.request_is_hydra_enabled?(request)
@@ -31,6 +31,8 @@ module NewRelic
         end
 
         def with_tracing
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           segment = NewRelic::Agent::Tracer.start_segment(name: HYDRA_SEGMENT_NAME)
           instance_variable_set(:@__newrelic_hydra_segment, segment)
           begin
@@ -41,6 +43,8 @@ module NewRelic
         end
 
         def self.trace(request)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           state = NewRelic::Agent::Tracer.state
           return unless state.is_execution_traced?
 

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

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

data/lib/new_relic/agent/instrumentation/view_component/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 ViewComponent::Chain
+    def self.instrument!
+      ::ViewComponent::Base.class_eval do
+        include NewRelic::Agent::Instrumentation::ViewComponent
+
+        alias_method(:render_in_without_tracing, :render_in)
+
+        def render_in(*args)
+          render_in_with_tracing(*args) do
+            render_in_without_tracing(*args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# 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 ViewComponent
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
+    def render_in_with_tracing(*args)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+      begin
+        segment = NewRelic::Agent::Tracer.start_segment(name: metric_name)
+        yield
+      rescue => e
+        NewRelic::Agent.notice_error(e)
+        raise
+      ensure
+        segment&.finish
+      end
+    end
+
+    def metric_name
+      # ViewComponent determines a component's identifier differently depending on the version
+      # https://github.com/ViewComponent/view_component/pull/2153
+      component_identifier = defined?(self.class.source_location) ? self.class.source_location : self.class.identifier
+
+      "View/#{metric_path(component_identifier)}/#{self.class.name}"
+    rescue => e
+      NewRelic::Agent.logger.error('Error identifying View Component metric name', e)
+
+      'View/component'
+    end
+
+    def metric_path(identifier)
+      return 'component' unless identifier
+
+      if (parts = identifier.split('/')).size > 1
+        parts[-2..-1].join('/') # Get filepath by assuming the Rails' structure: app/components/home/example_component.rb
+      else
+        NewRelic::Agent::UNKNOWN_METRIC
+      end
+    end
+  end
+end

data/lib/{tasks/instrumentation_generator/templates/instrumentation.tt → new_relic/agent/instrumentation/view_component/prepend.rb}

@@ -3,11 +3,11 @@
 # frozen_string_literal: true
 
 module NewRelic::Agent::Instrumentation
-  module <%= @class_name %>
+  module ViewComponent::Prepend
+    include NewRelic::Agent::Instrumentation::ViewComponent
 
-    def <%= @method.downcase %>_with_new_relic<%= "(#{@args})" unless @args.empty? %>
-      # add instrumentation content here
-      yield
+    def render_in(*args)
+      render_in_with_tracing(*args) { super }
     end
   end
 end

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

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -2,7 +2,6 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require 'base64'
 require 'json'
 require 'new_relic/agent/obfuscator'
 
@@ -165,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/llm/chat_completion_message.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
+
+module NewRelic
+  module Agent
+    module Llm
+      class ChatCompletionMessage < LlmEvent
+        ATTRIBUTES = %i[content role sequence completion_id token_count
+          is_response]
+        EVENT_NAME = 'LlmChatCompletionMessage'
+
+        attr_accessor(*ATTRIBUTES)
+
+        def attributes
+          LlmEvent::ATTRIBUTES + ATTRIBUTES
+        end
+
+        def event_name
+          EVENT_NAME
+        end
+      end
+    end
+  end
+end

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 NewRelic::Helper.version_satisfied?(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 NewRelic::Helper.version_satisfied?(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/local_log_decorator.rb

@@ -9,9 +9,15 @@ module NewRelic
       extend self
 
       def decorate(message)
-        return message unless decorating_enabled?
+        return message if !decorating_enabled? || message.nil?
 
         metadata = NewRelic::Agent.linking_metadata
+
+        if message.is_a?(Hash)
+          message.merge!(metadata) unless message.frozen?
+          return
+        end
+
         formatted_metadata = " NR-LINKING|#{metadata[ENTITY_GUID_KEY]}|#{metadata[HOSTNAME_KEY]}|" \
                              "#{metadata[TRACE_ID_KEY]}|#{metadata[SPAN_ID_KEY]}|" \
                              "#{escape_entity_name(metadata[ENTITY_NAME_KEY])}|"
@@ -23,14 +29,25 @@ module NewRelic
 
       def decorating_enabled?
         NewRelic::Agent.config[:'application_logging.enabled'] &&
-          NewRelic::Agent::Instrumentation::Logger.enabled? &&
+          (NewRelic::Agent::Instrumentation::Logger.enabled? ||
+            NewRelic::Agent::Instrumentation::LogStasher.enabled?) &&
           NewRelic::Agent.config[:'application_logging.local_decorating.enabled']
       end
 
       def escape_entity_name(entity_name)
         return unless entity_name
 
-        URI::DEFAULT_PARSER.escape(entity_name)
+        # TODO: OLD RUBIES 3.3
+        # URI version 1.0 marked URI::RFC3986_PARSER.escape as obsolete,
+        # which URI::DEFAULT_PARSER is an alias for.
+        # URI version 1.0+ will ship with Ruby 3.4
+        # Once we drop support for Rubies below 3.4, we can use the
+        # URI::RFC2396 parser exclusively.
+        if NewRelic::Helper.version_satisfied?(URI::VERSION, '>=', '1.0')
+          URI::RFC2396_PARSER.escape(entity_name)
+        else
+          URI::DEFAULT_PARSER.escape(entity_name)
+        end
       end
     end
   end