newrelic_rpm 9.1.0 → 9.21.0

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

@@ -92,16 +92,20 @@ 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
             elsif !value.nil?
               self[config_key] = true
             end
-          else
+          elsif !serverless?
             ::NewRelic::Agent.logger.info("#{environment_key} does not have a corresponding configuration setting (#{config_key} does not exist).")
-            ::NewRelic::Agent.logger.info('Run `rake newrelic:config:docs` or visit https://newrelic.com/docs/ruby/ruby-agent-configuration to see a list of available configuration settings.')
+            ::NewRelic::Agent.logger.info('Run `rake newrelic:config:docs` or visit https://docs.newrelic.com/docs/apm/agents/ruby-agent/configuration/ruby-agent-configuration to see a list of available configuration settings.')
             self[config_key] = value
           end
         end
@@ -114,6 +118,14 @@ module NewRelic
         def collect_new_relic_environment_variable_keys
           ENV.keys.select { |key| key.match(SUPPORTED_PREFIXES) }
         end
+
+        # we can't rely on the :'serverless_mode.enabled' config parameter being
+        # set yet to signify serverless mode given that we're in the midst of
+        # building the config but we can always rely on the env var being set
+        # by the Lambda layer
+        def serverless?
+          NewRelic::Agent::ServerlessHandler.env_var_set?
+        end
       end
     end
   end

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

@@ -19,6 +19,7 @@ module NewRelic
             :'elasticsearch.obfuscate_queries' => true,
             :'transaction_tracer.record_redis_arguments' => false,
 
+            :'ai_monitoring.enabled' => false,
             :'custom_insights_events.enabled' => false,
             :'strip_exception_messages.enabled' => true
           })

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

@@ -15,6 +15,8 @@ module NewRelic
   module Agent
     module Configuration
       class Manager
+        DEPENDENCY_DETECTION_VALUES = %i[prepend chain unsatisfied].freeze
+
         # Defining these explicitly saves object allocations that we incur
         # if we use Forwardable and def_delegators.
         def [](key)
@@ -32,6 +34,7 @@ module NewRelic
         def initialize
           reset_to_defaults
           @callbacks = Hash.new { |hash, key| hash[key] = [] }
+          @lock = Mutex.new
         end
 
         def add_config_for_testing(source, level = 0)
@@ -135,7 +138,14 @@ module NewRelic
         end
 
         def evaluate_and_apply_transformations(key, value)
-          apply_transformations(key, evaluate_procs(value))
+          evaluated = evaluate_procs(value)
+          default = enforce_allowlist(key, evaluated)
+          return default if default
+
+          boolean = enforce_boolean(key, value)
+          evaluated = boolean if [true, false].include?(boolean)
+
+          apply_transformations(key, evaluated)
         end
 
         def apply_transformations(key, value)
@@ -143,7 +153,7 @@ module NewRelic
             begin
               transform.call(value)
             rescue => e
-              ::NewRelic::Agent.logger.error("Error applying transformation for #{key}, pre-transform value was: #{value}.", e)
+              NewRelic::Agent.logger.error("Error applying transformation for #{key}, pre-transform value was: #{value}.", e)
               raise e
             end
           else
@@ -151,8 +161,33 @@ module NewRelic
           end
         end
 
+        def enforce_allowlist(key, value)
+          return unless allowlist = default_source.allowlist_for(key)
+          return if allowlist.include?(value)
+
+          default = default_source.default_for(key)
+          NewRelic::Agent.logger.warn "Invalid value '#{value}' for #{key}, applying default value of '#{default}'"
+          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)
-          ::NewRelic::Agent::Configuration::DefaultSource.transform_for(key)
+          default_source.transform_for(key)
+        end
+
+        def default_source
+          NewRelic::Agent::Configuration::DefaultSource
         end
 
         def register_callback(key, &proc)
@@ -211,7 +246,7 @@ module NewRelic
               begin
                 thawed_layer[k] = instance_eval(&v) if v.respond_to?(:call)
               rescue => e
-                ::NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} - when accessing config key #{k}")
+                NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} - when accessing config key #{k}")
                 thawed_layer[k] = nil
               end
               thawed_layer.delete(:config)
@@ -228,7 +263,7 @@ module NewRelic
         end
 
         def to_collector_hash
-          DottedHash.new(apply_mask(flattened)).to_hash.delete_if do |k, v|
+          DottedHash.new(apply_mask(flattened)).to_hash.delete_if do |k, _v|
             default = DEFAULTS[k]
             if default
               default[:exclude_from_reported_settings]
@@ -347,6 +382,7 @@ module NewRelic
           @security_policy_source = nil
           @high_security_source = nil
           @environment_source = EnvironmentSource.new
+          log_config(:add, @environment_source) # this is the only place the EnvironmentSource is ever created, so we should log it
           @server_source = nil
           @manual_source = nil
           @yaml_source = nil
@@ -357,17 +393,42 @@ module NewRelic
           reset_cache
         end
 
+        # reset the configuration hash, but do not replace previously auto
+        # determined dependency detection values with nil or 'auto'
         def reset_cache
+          return new_cache unless defined?(@cache) && @cache
+
+          # Modifying the @cache hash under JRuby - even with a `synchronize do`
+          # block and a `Hash#dup` operation - has been known to cause issues
+          # with JRuby for concurrent access of the hash while it is being
+          # 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 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) }
+            new_cache
+            preserved.each { |k, v| @cache[k] = v }
+          end
+
+          @cache
+        end
+
+        def new_cache
           @cache = Hash.new { |hash, key| hash[key] = self.fetch(key) }
         end
 
         def log_config(direction, source)
-          # Just generating this log message (specifically calling
-          # flattened.inspect) is expensive enough that we don't want to do it
-          # unless we're actually going to be logging the message based on our
-          # current log level.
-          ::NewRelic::Agent.logger.debug do
-            "Updating config (#{direction}) from #{source.class}. Results: #{flattened.inspect}"
+          # Just generating this log message (specifically calling `flattened`)
+          # is expensive enough that we don't want to do it unless we're
+          # actually going to be logging the message based on our current log
+          # level, so use a `do` block.
+          NewRelic::Agent.logger.debug do
+            source_hash = source.dup.to_h.delete_if { |k, _v| DEFAULTS.fetch(k, {}).fetch(:exclude_from_reported_settings, false) }
+            final_hash = flattened.delete_if { |k, _h| DEFAULTS.fetch(k, {}).fetch(:exclude_from_reported_settings, false) }
+
+            "Updating config (#{direction}) from #{source.class} with values: #{source_hash}. \nConfig Stack Results: #{final_hash.inspect}"
           end
         end
 

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

@@ -7,6 +7,8 @@ require 'new_relic/agent/configuration/dotted_hash'
 module NewRelic
   module Agent
     module Configuration
+      # The Language Security Policy Source gives customers the ability to
+      # configure high security mode settings.
       class SecurityPolicySource < DottedHash
         class << self
           def enabled?(option)
@@ -147,6 +149,15 @@ module NewRelic
               permitted_fn: nil
             }
           ],
+          'ai_monitoring' => [
+            {
+              option: :'ai_monitoring.enabled',
+              supported: true,
+              enabled_fn: method(:enabled?),
+              disabled_value: false,
+              permitted_fn: nil
+            }
+          ],
           'allow_raw_exception_messages' => [
             {
               option: :'strip_exception_messages.enabled',

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

@@ -36,11 +36,13 @@ module NewRelic
             erb_file = process_erb(raw_file)
             config = process_yaml(erb_file, env, config, @file_path)
           rescue ScriptError, StandardError => e
+            NewRelic::Agent.agent&.health_check&.update_status(NewRelic::Agent::HealthCheck::FAILED_TO_PARSE_CONFIG)
             log_failure("Failed to read or parse configuration file at #{path}", e)
           end
 
           substitute_transaction_threshold(config)
           booleanify_values(config, 'agent_enabled', 'enabled')
+          apply_aliases(config)
 
           super(config, true)
         end
@@ -52,6 +54,8 @@ module NewRelic
         protected
 
         def validate_config_file_path(path)
+          return if NewRelic::Agent.config[:'serverless_mode.enabled']
+
           expanded_path = File.expand_path(path)
 
           if path.empty? || !File.exist?(expanded_path)
@@ -63,7 +67,7 @@ module NewRelic
         end
 
         def warn_missing_config_file(path)
-          based_on = 'unknown'
+          based_on = NewRelic::UNKNOWN_LOWER
           source = ::NewRelic::Agent.config.source(:config_path)
           candidate_paths = [path]
 
@@ -96,7 +100,11 @@ module NewRelic
             file.gsub!(/^\s*#.*$/, '#')
             ERB.new(file).result(binding)
           rescue ScriptError, StandardError => e
-            log_failure('Failed ERB processing configuration file. This is typically caused by a Ruby error in <% %> templating blocks in your newrelic.yml file.', e)
+            NewRelic::Agent.agent&.health_check&.update_status(NewRelic::Agent::HealthCheck::FAILED_TO_PARSE_CONFIG)
+            message = 'Failed ERB processing configuration file. This is typically caused by a Ruby error in <% %> templating blocks in your newrelic.yml file.'
+            failure_array = [message, e]
+            failure_array << e.backtrace[0] if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '>=', '3.4.0')
+            log_failure(*failure_array)
             nil
           end
         end
@@ -165,6 +173,18 @@ module NewRelic
           end
           result
         end
+
+        def apply_aliases(config)
+          DEFAULTS.each do |config_setting, value|
+            next unless value[:aliases]
+
+            value[:aliases].each do |config_alias|
+              next unless config[config_setting].nil? && !config[config_alias.to_s].nil?
+
+              config[config_setting] = config[config_alias.to_s]
+            end
+          end
+        end
       end
     end
   end

data/lib/new_relic/agent/connect/request_builder.rb

@@ -24,7 +24,7 @@ module NewRelic
             :host => local_host,
             :display_host => Agent.config[:'process_host.display_name'],
             :app_name => Agent.config[:app_name],
-            :language => 'ruby',
+            :language => LANGUAGE,
             :labels => Agent.config.parsed_labels,
             :agent_version => NewRelic::VERSION::STRING,
             :environment => @environment_report,

data/lib/new_relic/agent/custom_event_aggregator.rb

@@ -14,6 +14,9 @@ module NewRelic
       TIMESTAMP = 'timestamp'.freeze
       PRIORITY = 'priority'.freeze
       EVENT_TYPE_REGEX = /^[a-zA-Z0-9:_ ]+$/.freeze
+      MAX_ATTRIBUTE_COUNT = 64
+      MAX_ATTRIBUTE_SIZE = 4095
+      MAX_NAME_SIZE = 255
 
       named :CustomEventAggregator
       capacity_key :'custom_insights_events.max_samples_stored'
@@ -49,10 +52,33 @@ module NewRelic
           {TYPE => type,
            TIMESTAMP => Process.clock_gettime(Process::CLOCK_REALTIME).to_i,
            PRIORITY => priority},
-          AttributeProcessing.flatten_and_coerce(attributes)
+          create_custom_event_attributes(type, attributes)
         ]
       end
 
+      def create_custom_event_attributes(type, attributes)
+        result = AttributeProcessing.flatten_and_coerce(attributes)
+
+        if result.size > MAX_ATTRIBUTE_COUNT
+          NewRelic::Agent.logger.warn("Custom event attributes are limited to #{MAX_ATTRIBUTE_COUNT}. Discarding #{result.size - MAX_ATTRIBUTE_COUNT} attributes")
+          result = result.first(MAX_ATTRIBUTE_COUNT)
+        end
+
+        result.each_with_object({}) do |(key, val), new_result|
+          # name is limited to 255
+          if key.is_a?(String) && key.length > MAX_NAME_SIZE
+            key = key[0, MAX_NAME_SIZE]
+          end
+
+          # value is limited to 4095 except for LLM content-related events
+          if val.is_a?(String) && val.length > MAX_ATTRIBUTE_SIZE
+            val = val[0, MAX_ATTRIBUTE_SIZE] unless NewRelic::Agent::LLM.exempt_event_attribute?(type, key)
+          end
+
+          new_result[key] = val
+        end
+      end
+
       def after_initialize
         @type_strings = Hash.new { |hash, key| hash[key] = key.to_s.freeze }
       end

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/database/obfuscator.rb

@@ -2,6 +2,7 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
+require 'singleton'
 require 'new_relic/agent/database/obfuscation_helpers'
 
 module NewRelic

data/lib/new_relic/agent/database.rb

@@ -90,6 +90,42 @@ module NewRelic
         ConnectionManager.instance.get_connection(config, &connector)
       end
 
+      def explain_this(statement, use_execute = false)
+        if supports_with_connection?
+          explain_this_using_with_connection(statement)
+        else
+          explain_this_using_adapter_connection(statement, use_execute)
+        end
+      rescue => e
+        NewRelic::Agent.logger.error("Couldn't fetch the explain plan for statement: #{e}")
+      end
+
+      def explain_this_using_with_connection(statement)
+        ::ActiveRecord::Base.with_connection do |conn|
+          conn.exec_query("EXPLAIN #{statement.sql}", "Explain #{statement.name}", statement.binds)
+        end
+      end
+
+      def explain_this_using_adapter_connection(statement, use_execute)
+        connection = get_connection(statement.config) do
+          ::ActiveRecord::Base.send(:"#{statement.config[:adapter]}_connection", statement.config)
+        end
+
+        if use_execute
+          connection.execute("EXPLAIN #{statement.sql}")
+        else
+          connection.exec_query("EXPLAIN #{statement.sql}", "Explain #{statement.name}", statement.binds)
+        end
+      end
+
+      # ActiveRecord v7.2.0 introduced with_connection
+      def supports_with_connection?
+        return @supports_with_connection if defined?(@supports_with_connection)
+
+        @supports_with_connection = defined?(::ActiveRecord::VERSION::STRING) &&
+          NewRelic::Helper.version_satisfied?(ActiveRecord::VERSION::STRING, '>=', '7.2.0')
+      end
+
       def close_connections
         ConnectionManager.instance.close_connections
       end
@@ -241,9 +277,11 @@ module NewRelic
         MYSQL_PREFIX = 'mysql'.freeze
         MYSQL2_PREFIX = 'mysql2'.freeze
         SQLITE_PREFIX = 'sqlite'.freeze
+        TRILOGY_PREFIX = 'trilogy'.freeze
+        REDSHIFT_PREFIX = 'redshift'.freeze
 
         def symbolized_adapter(adapter)
-          if adapter.start_with?(POSTGRES_PREFIX) || adapter == POSTGIS_PREFIX
+          if adapter.start_with?(POSTGRES_PREFIX) || adapter == POSTGIS_PREFIX || adapter == REDSHIFT_PREFIX
             :postgres
           elsif adapter == MYSQL_PREFIX
             :mysql
@@ -253,6 +291,8 @@ module NewRelic
             :mysql2
           elsif adapter.start_with?(SQLITE_PREFIX)
             :sqlite
+          elsif adapter == TRILOGY_PREFIX
+            :trilogy
           else
             adapter.to_sym
           end

data/lib/new_relic/agent/database_adapter.rb

@@ -25,7 +25,7 @@ module NewRelic
       end
 
       def value
-        match = VERSIONS.keys.find { |key| version >= Gem::Version.new(key) }
+        match = VERSIONS.keys.find { |key| NewRelic::Helper.version_satisfied?(version, '>=', key) }
         return unless match
 
         VERSIONS[match].call(env)

data/lib/new_relic/agent/datastores/mongo/metric_translator.rb

@@ -128,7 +128,7 @@ module NewRelic
           end
 
           def self.drop_indexes?(name, payload)
-            name == :deleteIndexes && payload[:selector] && payload[:selector][:index] == '*'
+            name == :deleteIndexes && payload[:selector] && payload[:selector][:index] == ASTERISK
           end
 
           def self.drop_index?(name, payload)

data/lib/new_relic/agent/datastores/redis.rb

@@ -83,7 +83,7 @@ module NewRelic
         end
 
         def self.is_supported_version?
-          Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('3.0.0')
+          NewRelic::Helper.version_satisfied?(::Redis::VERSION, '>=', '3.0.0')
         end
 
         def self.ellipsize(result, string)

data/lib/new_relic/agent/distributed_tracing/cross_app_tracing.rb

@@ -207,7 +207,7 @@ module NewRelic
         decoded_appdata.set_encoding(::Encoding::UTF_8) if
           decoded_appdata.respond_to?(:set_encoding)
 
-        ::JSON.load(decoded_appdata)
+        ::JSON.parse(decoded_appdata)
       end
 
       def valid_cross_app_id?(xp_id)

data/lib/new_relic/agent/distributed_tracing/distributed_trace_payload.rb

@@ -3,7 +3,7 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'base64'
+require 'new_relic/base64'
 
 module NewRelic
   module Agent
@@ -35,7 +35,7 @@ module NewRelic
 
       class << self
         def for_transaction(transaction)
-          return nil unless connected?
+          return nil unless Agent.instance.connected?
 
           payload = new
           payload.version = VERSION
@@ -78,7 +78,7 @@ module NewRelic
         end
 
         def from_http_safe(http_safe_payload)
-          decoded_payload = Base64.strict_decode64(http_safe_payload)
+          decoded_payload = NewRelic::Base64.strict_decode64(http_safe_payload)
           from_json(decoded_payload)
         end
 
@@ -101,10 +101,6 @@ module NewRelic
             transaction.current_segment.guid
           end
         end
-
-        def connected?
-          Agent.instance.connected?
-        end
       end
 
       attr_accessor :version,
@@ -156,7 +152,7 @@ module NewRelic
       #
       # @api public
       def http_safe
-        Base64.strict_encode64(text)
+        NewRelic::Base64.strict_encode64(text)
       end
     end
   end

data/lib/new_relic/agent/distributed_tracing.rb

@@ -39,13 +39,14 @@ module NewRelic
       # @return           {Transaction}     The transaction the headers were inserted from,
       #                                     or +nil+ if headers were not inserted.
       #
+      # @!scope class
       # @api public
       #
       def insert_distributed_trace_headers(headers = {})
         record_api_supportability_metric(:insert_distributed_trace_headers)
 
         unless Agent.config[:'distributed_tracing.enabled']
-          NewRelic::Agent.logger.warn('Not configured to insert distributed trace headers')
+          NewRelic::Agent.logger.debug('Not configured to insert distributed trace headers')
           return nil
         end
 
@@ -87,19 +88,20 @@ module NewRelic
       #                                   header-friendly string returned from
       #                                   {DistributedTracePayload#http_safe}
       #
-      # @param transport_Type  [String]   May be one of:  +HTTP+, +HTTPS+, +Kafka+, +JMS+,
+      # @param transport_type  [String]   May be one of:  +HTTP+, +HTTPS+, +Kafka+, +JMS+,
       #                                   +IronMQ+, +AMQP+, +Queue+, +Other+.  Values are
       #                                   case sensitive.  All other values result in +Unknown+
       #
       # @return {Transaction} if successful, +nil+ otherwise
       #
+      # @!scope class
       # @api public
       #
       def accept_distributed_trace_headers(headers, transport_type = NewRelic::HTTP)
         record_api_supportability_metric(:accept_distributed_trace_headers)
 
         unless Agent.config[:'distributed_tracing.enabled']
-          NewRelic::Agent.logger.warn('Not configured to accept distributed trace headers')
+          NewRelic::Agent.logger.debug('Not configured to accept distributed trace headers')
           return nil
         end
 

data/lib/new_relic/agent/error_collector.rb

@@ -110,6 +110,29 @@ module NewRelic
         false
       end
 
+      # Neither ignored nor expected errors impact apdex.
+      #
+      # Ignored errors are checked via `#error_is_ignored?`
+      # Expected errors are checked in 2 separate ways:
+      #   1. The presence of an `expected: true` attribute key/value pair in the
+      #      options hash, which will be set if that key/value pair was used in
+      #      the `notice_error` public API.
+      #   2. By calling `#expected?` which in turn calls `ErrorFilter#expected?`
+      #      which checks for 3 things:
+      #        - A match for user-defined HTTP status codes to expect
+      #        - A match for user-defined error classes to expect
+      #        - A match for user-defined error messages to expect
+      def error_affects_apdex?(error, options)
+        return false if error_is_ignored?(error)
+        return false if options[:expected]
+
+        !expected?(error, ::NewRelic::Agent::Tracer.state.current_transaction&.http_response_code)
+      rescue => e
+        NewRelic::Agent.logger.error("Could not determine if error '#{error}' should impact Apdex - " \
+                                     "#{e.class}: #{e.message}. Defaulting to 'true' (it should impact Apdex).")
+        true
+      end
+
       # Calling instance_variable_set on a wrapped Java object in JRuby will
       # generate a warning unless that object's class has already been marked
       # as persistent, so we skip tagging of exception objects that are actually
@@ -214,7 +237,10 @@ module NewRelic
       end
 
       def notice_segment_error(segment, exception, options = {})
-        return if skip_notice_error?(exception)
+        status_code = process_http_status_code(exception, options)
+        return if skip_notice_error?(exception, status_code)
+
+        options.merge!(segment.llm_event.error_attributes(exception)) if segment.llm_event
 
         segment.set_noticed_error(create_noticed_error(exception, options))
         exception
@@ -225,15 +251,13 @@ module NewRelic
 
       # See NewRelic::Agent.notice_error for options and commentary
       def notice_error(exception, options = {}, span_id = nil)
-        state = ::NewRelic::Agent::Tracer.state
-        transaction = state.current_transaction
-        status_code = transaction&.http_response_code
-
+        status_code = process_http_status_code(exception, options)
         return if skip_notice_error?(exception, status_code)
 
         tag_exception(exception)
 
-        if options[:expected] || @error_filter.expected?(exception, status_code)
+        state = ::NewRelic::Agent::Tracer.state
+        if options[:expected]
           increment_expected_error_count!(state, exception)
         else
           increment_error_count!(state, exception, options)
@@ -241,10 +265,8 @@ module NewRelic
 
         noticed_error = create_noticed_error(exception, options)
         error_trace_aggregator.add_to_error_queue(noticed_error)
-        transaction = state.current_transaction
-        payload = transaction&.payload
-        span_id ||= transaction&.current_segment ? transaction.current_segment.guid : nil
-        error_event_aggregator.record(noticed_error, payload, span_id)
+        span_id ||= state.current_transaction&.current_segment&.guid
+        error_event_aggregator.record(noticed_error, state.current_transaction&.payload, span_id)
         exception
       rescue => e
         ::NewRelic::Agent.logger.warn("Failure when capturing error '#{exception}':", e)
@@ -277,7 +299,7 @@ module NewRelic
         noticed_error.line_number = sense_method(exception, :line_number)
         noticed_error.stack_trace = truncate_trace(extract_stack_trace(exception))
 
-        noticed_error.expected = !options.delete(:expected).nil? || expected?(exception)
+        noticed_error.expected = !!options.delete(:expected) || expected?(exception) # rubocop:disable Style/DoubleNegation
 
         noticed_error.attributes_from_notice_error = options.delete(:custom_params) || {}
 
@@ -334,6 +356,13 @@ module NewRelic
       def error_group_callback
         NewRelic::Agent.error_group_callback
       end
+
+      def process_http_status_code(exception, options)
+        status_code = ::NewRelic::Agent::Tracer.state.current_transaction&.http_response_code
+        options[:expected] = true if !options[:expected] && @error_filter.expected?(exception, status_code)
+
+        status_code
+      end
     end
   end
 end