newrelic_rpm 9.8.0 → 9.10.0

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

@@ -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
@@ -101,10 +101,6 @@ module NewRelic
             transaction.current_segment.guid
           end
         end
-
-        def connected?
-          Agent.instance.connected?
-        end
       end
 
       attr_accessor :version,

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

data/lib/new_relic/agent/harvester.rb

@@ -38,7 +38,7 @@ module NewRelic
       end
 
       def harvest_thread_enabled?
-        !NewRelic::Agent.config[:disable_harvest_thread]
+        !NewRelic::Agent.config[:disable_harvest_thread] && !NewRelic::Agent.config[:'serverless_mode.enabled']
       end
 
       def restart_harvest_thread

data/lib/new_relic/agent/instrumentation/dynamodb/chain.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
+
+module NewRelic::Agent::Instrumentation
+  module DynamoDB::Chain
+    def self.instrument!
+      ::Aws::DynamoDB::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::DynamoDB
+
+        NewRelic::Agent::Instrumentation::DynamoDB::INSTRUMENTED_METHODS.each do |method_name|
+          alias_method("#{method_name}_without_new_relic".to_sym, method_name.to_sym)
+
+          define_method(method_name) do |*args|
+            instrument_method_with_new_relic(method_name, *args) { send("#{method_name}_without_new_relic".to_sym, *args) }
+          end
+        end
+
+        alias_method(:build_request_without_new_relic, :build_request)
+
+        def build_request(*args)
+          build_request_with_new_relic(*args) { build_request_without_new_relic(*args) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# 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 DynamoDB
+    INSTRUMENTED_METHODS = %w[
+      create_table
+      delete_item
+      delete_table
+      get_item
+      put_item
+      query
+      scan
+      update_item
+    ].freeze
+
+    PRODUCT = 'DynamoDB'
+    DEFAULT_HOST = 'dynamodb.amazonaws.com'
+
+    def instrument_method_with_new_relic(method_name, *args)
+      return yield unless NewRelic::Agent::Tracer.tracing_enabled?
+
+      NewRelic::Agent.record_instrumentation_invocation(PRODUCT)
+
+      segment = NewRelic::Agent::Tracer.start_datastore_segment(
+        product: PRODUCT,
+        operation: method_name,
+        host: config&.endpoint&.host || DEFAULT_HOST,
+        port_path_or_id: config&.endpoint&.port,
+        collection: args[0][:table_name]
+      )
+
+      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
+        NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+      ensure
+        segment&.add_agent_attribute('aws.operation', method_name)
+        segment&.add_agent_attribute('aws.requestId', @nr_captured_request&.context&.http_response&.headers&.[]('x-amzn-requestid'))
+        segment&.add_agent_attribute('aws.region', config&.region)
+        segment&.finish
+      end
+    end
+
+    def build_request_with_new_relic(*args)
+      @nr_captured_request = yield
+    end
+
+    def get_arn(params)
+      return unless params[:table_name]
+
+      NewRelic::Agent::Aws.create_arn(PRODUCT.downcase, "table/#{params[:table_name]}", config)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# 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 DynamoDB::Prepend
+    include NewRelic::Agent::Instrumentation::DynamoDB
+
+    INSTRUMENTED_METHODS.each do |method_name|
+      define_method(method_name) do |*args|
+        instrument_method_with_new_relic(method_name, *args) { super(*args) }
+      end
+    end
+
+    def build_request(*args)
+      build_request_with_new_relic(*args) { super }
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'dynamodb/instrumentation'
+require_relative 'dynamodb/chain'
+require_relative 'dynamodb/prepend'
+
+DependencyDetection.defer do
+  named :dynamodb
+
+  depends_on do
+    defined?(Aws::DynamoDB::Client)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing DynamoDB instrumentation')
+
+    if use_prepend?
+      prepend_instrument Aws::DynamoDB::Client, NewRelic::Agent::Instrumentation::DynamoDB::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::DynamoDB::Chain
+    end
+  end
+end

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

@@ -10,7 +10,11 @@ module NewRelic::Agent::Instrumentation
     OPERATION = 'perform_request'
     INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
-    def perform_request_with_tracing(method, path, params = {}, body = nil, headers = nil)
+    # We need the positional arguments `params` and `body`
+    # to capture the nosql statement
+    # *args protects the instrumented method if new arguments are added to
+    # perform_request
+    def perform_request_with_tracing(_method, _path, params = {}, body = nil, _headers = nil, *_args)
       return yield unless NewRelic::Agent::Tracer.tracing_enabled?
 
       NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
@@ -22,6 +26,7 @@ module NewRelic::Agent::Instrumentation
         port_path_or_id: nr_hosts[:port],
         database_name: nr_cluster_name
       )
+
       begin
         NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
       ensure

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

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

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

@@ -68,7 +68,7 @@ module NewRelic::Agent::Instrumentation
         vendor: VENDOR,
         request_max_tokens: (parameters[:max_tokens] || parameters['max_tokens'])&.to_i,
         request_model: parameters[:model] || parameters['model'],
-        temperature: (parameters[:temperature] || parameters['temperature'])&.to_f,
+        request_temperature: (parameters[:temperature] || parameters['temperature'])&.to_f,
         metadata: llm_custom_attributes
       )
     end
@@ -128,7 +128,6 @@ module NewRelic::Agent::Instrumentation
     def update_chat_completion_messages(messages, response, summary)
       messages += create_chat_completion_response_messages(response, messages.size, summary.id)
       response_id = response['id'] || NewRelic::Agent::GuidGenerator.generate_guid
-
       messages.each do |message|
         message.id = "#{response_id}-#{message.sequence}"
         message.request_id = summary.request_id

data/lib/new_relic/agent/log_event_aggregator.rb

@@ -247,21 +247,6 @@ module NewRelic
         message.byteslice(0...MAX_BYTES)
       end
 
-      def minimum_log_level
-        if Logger::Severity.constants.include?(configured_log_level_constant)
-          configured_log_level_constant
-        else
-          NewRelic::Agent.logger.log_once(
-            :error,
-            'Invalid application_logging.forwarding.log_level ' \
-            "'#{NewRelic::Agent.config[LOG_LEVEL_KEY]}' specified! " \
-            "Must be one of #{Logger::Severity.constants.join('|')}. " \
-            "Using default level of 'debug'"
-          )
-          :DEBUG
-        end
-      end
-
       def configured_log_level_constant
         format_log_level_constant(NewRelic::Agent.config[LOG_LEVEL_KEY])
       end
@@ -275,7 +260,7 @@ module NewRelic
         # always record custom log levels
         return false unless Logger::Severity.constants.include?(severity_constant)
 
-        Logger::Severity.const_get(severity_constant) < Logger::Severity.const_get(minimum_log_level)
+        Logger::Severity.const_get(severity_constant) < Logger::Severity.const_get(configured_log_level_constant)
       end
     end
   end

data/lib/new_relic/agent/new_relic_service.rb

@@ -143,6 +143,9 @@ module NewRelic
       end
 
       def metric_data(stats_hash)
+        # let the serverless handler handle serialization
+        return NewRelic::Agent.agent.serverless_handler.metric_data(stats_hash) if NewRelic::Agent.agent.serverless?
+
         timeslice_start = stats_hash.started_at
         timeslice_end = stats_hash.harvested_at || Process.clock_gettime(Process::CLOCK_REALTIME)
         metric_data_array = build_metric_data_array(stats_hash)
@@ -154,6 +157,9 @@ module NewRelic
       end
 
       def error_data(unsent_errors)
+        # let the serverless handler handle serialization
+        return NewRelic::Agent.agent.serverless_handler.error_data(unsent_errors) if NewRelic::Agent.agent.serverless?
+
         invoke_remote(:error_data, [@agent_id, unsent_errors],
           :item_count => unsent_errors.size)
       end
@@ -554,6 +560,8 @@ module NewRelic
       # enough to be worth compressing, and handles any errors the
       # server may return
       def invoke_remote(method, payload = [], options = {})
+        return NewRelic::Agent.agent.serverless_handler.store_payload(method, payload) if NewRelic::Agent.agent.serverless?
+
         start_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         request_send_ts, response_check_ts = nil
         data, encoding, size, serialize_finish_ts = marshal_payload(method, payload, options)
@@ -561,8 +569,10 @@ module NewRelic
         response, request_send_ts, response_check_ts = invoke_remote_send_request(method, payload, data, encoding)
         @marshaller.load(decompress_response(response))
       ensure
-        record_timing_supportability_metrics(method, start_ts, serialize_finish_ts, request_send_ts, response_check_ts)
-        record_size_supportability_metrics(method, size, options[:item_count]) if size
+        unless NewRelic::Agent.agent.serverless?
+          record_timing_supportability_metrics(method, start_ts, serialize_finish_ts, request_send_ts, response_check_ts)
+          record_size_supportability_metrics(method, size, options[:item_count]) if size
+        end
       end
 
       def handle_serialization_error(method, e)

data/lib/new_relic/agent/serverless_handler.rb

@@ -0,0 +1,171 @@
+# 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 'json'
+require 'new_relic/base64'
+
+module NewRelic
+  module Agent
+    class ServerlessHandler
+      ATTRIBUTE_ARN = 'aws.lambda.arn'
+      ATTRIBUTE_COLD_START = 'aws.lambda.coldStart'
+      ATTRIBUTE_REQUEST_ID = 'aws.requestId'
+      AGENT_ATTRIBUTE_DESTINATIONS = NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER |
+        NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS
+      EXECUTION_ENVIRONMENT = "AWS_Lambda_ruby#{RUBY_VERSION.rpartition('.').first}".freeze
+      LAMBDA_MARKER = 'NR_LAMBDA_MONITORING'
+      LAMBDA_ENVIRONMENT_VARIABLE = 'AWS_LAMBDA_FUNCTION_NAME'
+      METHOD_BLOCKLIST = %i[agent_command_results connect get_agent_commands preconnect profile_data
+        shutdown].freeze
+      NAMED_PIPE = '/tmp/newrelic-telemetry'
+      SUPPORTABILITY_METRIC = 'Supportability/AWSLambda/HandlerInvocation'
+      FUNCTION_NAME = 'lambda_function'
+      PAYLOAD_VERSION = ENV.fetch('NEW_RELIC_SERVERLESS_PAYLOAD_VERSION', 2)
+
+      def self.env_var_set?
+        ENV.key?(LAMBDA_ENVIRONMENT_VARIABLE)
+      end
+
+      def initialize
+        @context = nil
+        @payloads = {}
+      end
+
+      def invoke_lambda_function_with_new_relic(event:, context:, method_name:, namespace: nil)
+        NewRelic::Agent.increment_metric(SUPPORTABILITY_METRIC)
+
+        @context = context
+
+        NewRelic::Agent::Tracer.in_transaction(category: :other, name: function_name) do
+          add_agent_attributes
+
+          NewRelic::LanguageSupport.constantize(namespace).send(method_name, event: event, context: context)
+        end
+      ensure
+        harvest!
+        write_output
+        reset!
+      end
+
+      def store_payload(method, payload)
+        return if METHOD_BLOCKLIST.include?(method)
+
+        @payloads[method] = payload
+      end
+
+      def metric_data(stats_hash)
+        payload = [nil,
+          stats_hash.started_at,
+          (stats_hash.harvested_at || Process.clock_gettime(Process::CLOCK_REALTIME)),
+          []]
+        stats_hash.each do |metric_spec, stats|
+          next if stats.is_reset?
+
+          hash = {name: metric_spec.name}
+          hash[:scope] = metric_spec.scope unless metric_spec.scope.empty?
+
+          payload.last.push([hash, [
+            stats.call_count,
+            stats.total_call_time,
+            stats.total_exclusive_time,
+            stats.min_call_time,
+            stats.max_call_time,
+            stats.sum_of_squares
+          ]])
+        end
+
+        return if payload.last.empty?
+
+        store_payload(:metric_data, payload)
+      end
+
+      def error_data(errors)
+        store_payload(:error_data, [nil, errors.map(&:to_collector_array)])
+      end
+
+      private
+
+      def harvest!
+        NewRelic::Agent.instance.harvest_and_send_analytic_event_data
+        NewRelic::Agent.instance.harvest_and_send_custom_event_data
+        NewRelic::Agent.instance.harvest_and_send_data_types
+      end
+
+      def metadata
+        m = {arn: @context.invoked_function_arn,
+             protocol_version: NewRelic::Agent::NewRelicService::PROTOCOL_VERSION,
+             function_version: @context.function_version,
+             execution_environment: EXECUTION_ENVIRONMENT,
+             agent_version: NewRelic::VERSION::STRING}
+        if PAYLOAD_VERSION >= 2
+          m[:metadata_version] = PAYLOAD_VERSION
+          m[:agent_language] = NewRelic::LANGUAGE
+        end
+        m
+      end
+
+      def function_name
+        ENV.fetch(LAMBDA_ENVIRONMENT_VARIABLE, FUNCTION_NAME)
+      end
+
+      def write_output
+        string = PAYLOAD_VERSION == 1 ? payload_v1 : payload_v2
+
+        return puts string unless use_named_pipe?
+
+        File.write(NAMED_PIPE, string)
+
+        NewRelic::Agent.logger.debug "Wrote serverless payload to #{NAMED_PIPE}\n" \
+          "BEGIN PAYLOAD>>>\n#{string}\n<<<END PAYLOAD"
+      end
+
+      def payload_v1
+        payload_hash = {'metadata' => metadata, 'data' => @payloads}
+        json = NewRelic::Agent.agent.service.marshaller.dump(payload_hash)
+        gzipped = NewRelic::Agent::NewRelicService::Encoders::Compressed::Gzip.encode(json)
+        base64_encoded = NewRelic::Base64.strict_encode64(gzipped)
+        array = [PAYLOAD_VERSION, LAMBDA_MARKER, base64_encoded]
+        ::JSON.dump(array)
+      end
+
+      def payload_v2
+        json = NewRelic::Agent.agent.service.marshaller.dump(@payloads)
+        gzipped = NewRelic::Agent::NewRelicService::Encoders::Compressed::Gzip.encode(json)
+        base64_encoded = NewRelic::Base64.strict_encode64(gzipped)
+        array = [PAYLOAD_VERSION, LAMBDA_MARKER, metadata, base64_encoded]
+        ::JSON.dump(array)
+      end
+
+      def use_named_pipe?
+        return @use_named_pipe if defined?(@use_named_pipe)
+
+        @use_named_pipe = File.exist?(NAMED_PIPE) && File.writable?(NAMED_PIPE)
+      end
+
+      def add_agent_attributes
+        return unless NewRelic::Agent::Tracer.current_transaction
+
+        add_agent_attribute(ATTRIBUTE_COLD_START, true) if cold?
+        add_agent_attribute(ATTRIBUTE_ARN, @context.invoked_function_arn)
+        add_agent_attribute(ATTRIBUTE_REQUEST_ID, @context.aws_request_id)
+      end
+
+      def add_agent_attribute(attribute, value)
+        NewRelic::Agent::Tracer.current_transaction.add_agent_attribute(attribute, value, AGENT_ATTRIBUTE_DESTINATIONS)
+      end
+
+      def cold?
+        return @cold if defined?(@cold)
+
+        @cold = false
+        true
+      end
+
+      def reset!
+        @context = nil
+        @payloads.replace({})
+      end
+    end
+  end
+end

data/lib/new_relic/agent/span_event_primitive.rb

@@ -79,17 +79,13 @@ module NewRelic
         intrinsics[SPAN_KIND_KEY] = CLIENT
         intrinsics[SERVER_ADDRESS_KEY] = segment.uri.host
         intrinsics[SERVER_PORT_KEY] = segment.uri.port
-        agent_attributes = error_attributes(segment) || {}
+        agent_attributes = {}
 
         if allowed?(HTTP_URL_KEY)
           agent_attributes[HTTP_URL_KEY] = truncate(segment.uri)
         end
 
-        if segment.respond_to?(:record_agent_attributes?) && segment.record_agent_attributes?
-          agent_attributes.merge!(agent_attributes(segment))
-        end
-
-        [intrinsics, custom_attributes(segment), agent_attributes]
+        [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
       end
 
       def for_datastore_segment(segment) # rubocop:disable Metrics/AbcSize
@@ -99,7 +95,7 @@ module NewRelic
         intrinsics[SPAN_KIND_KEY] = CLIENT
         intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
 
-        agent_attributes = error_attributes(segment) || {}
+        agent_attributes = {}
 
         if segment.database_name && allowed?(DB_INSTANCE_KEY)
           agent_attributes[DB_INSTANCE_KEY] = truncate(segment.database_name)
@@ -123,7 +119,7 @@ module NewRelic
           agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
         end
 
-        [intrinsics, custom_attributes(segment), agent_attributes]
+        [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
       end
 
       private

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

@@ -23,7 +23,6 @@ module NewRelic
         MISSING_STATUS_CODE = 'MissingHTTPStatusCode'
 
         attr_reader :library, :uri, :procedure, :http_status_code
-        attr_writer :record_agent_attributes
 
         def initialize(library, uri, procedure, start_time = nil) # :nodoc:
           @library = library
@@ -32,7 +31,6 @@ module NewRelic
           @host_header = nil
           @app_data = nil
           @http_status_code = nil
-          @record_agent_attributes = false
           super(nil, nil, start_time)
         end
 
@@ -44,14 +42,6 @@ module NewRelic
           @host_header || uri.host
         end
 
-        # By default external request segments only have errors and the http
-        # url recorded as agent attributes. To have all the agent attributes
-        # recorded, use the attr_writer like so `segment.record_agent_attributes = true`
-        # See: SpanEventPrimitive#for_external_request_segment
-        def record_agent_attributes?
-          @record_agent_attributes
-        end
-
         # This method adds New Relic request headers to a given request made to an
         # external API and checks to see if a host header is used for the request.
         # If a host header is used, it updates the segment name to match the host

data/lib/new_relic/agent/transaction.rb

@@ -816,13 +816,9 @@ module NewRelic
       end
 
       def had_error_affecting_apdex?
-        @exceptions.each do |exception, options|
-          ignored = NewRelic::Agent.instance.error_collector.error_is_ignored?(exception)
-          expected = options[:expected]
-
-          return true unless ignored || expected
+        @exceptions.each.any? do |exception, options|
+          NewRelic::Agent.instance.error_collector.error_affects_apdex?(exception, options)
         end
-        false
       end
 
       def apdex_bucket(duration, current_apdex_t)

data/lib/new_relic/agent/transaction_error_primitive.rb

@@ -16,26 +16,27 @@ module NewRelic
     module TransactionErrorPrimitive
       extend self
 
-      SAMPLE_TYPE = 'TransactionError'.freeze
-      TYPE_KEY = 'type'.freeze
-      ERROR_CLASS_KEY = 'error.class'.freeze
-      ERROR_MESSAGE_KEY = 'error.message'.freeze
-      ERROR_EXPECTED_KEY = 'error.expected'.freeze
-      TIMESTAMP_KEY = 'timestamp'.freeze
-      PORT_KEY = 'port'.freeze
-      NAME_KEY = 'transactionName'.freeze
-      DURATION_KEY = 'duration'.freeze
-      SAMPLED_KEY = 'sampled'.freeze
-      GUID_KEY = 'nr.transactionGuid'.freeze
-      REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'.freeze
-      SYNTHETICS_RESOURCE_ID_KEY = 'nr.syntheticsResourceId'.freeze
-      SYNTHETICS_JOB_ID_KEY = 'nr.syntheticsJobId'.freeze
-      SYNTHETICS_MONITOR_ID_KEY = 'nr.syntheticsMonitorId'.freeze
+      SAMPLE_TYPE = 'TransactionError'
+      TYPE_KEY = 'type'
+      ERROR_CLASS_KEY = 'error.class'
+      ERROR_MESSAGE_KEY = 'error.message'
+      ERROR_EXPECTED_KEY = 'error.expected'
+      TIMESTAMP_KEY = 'timestamp'
+      PORT_KEY = 'port'
+      NAME_KEY = 'transactionName'
+      DURATION_KEY = 'duration'
+      SAMPLED_KEY = 'sampled'
+      CAT_GUID_KEY = 'nr.transactionGuid'
+      CAT_REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'
+      SYNTHETICS_RESOURCE_ID_KEY = 'nr.syntheticsResourceId'
+      SYNTHETICS_JOB_ID_KEY = 'nr.syntheticsJobId'
+      SYNTHETICS_MONITOR_ID_KEY = 'nr.syntheticsMonitorId'
       SYNTHETICS_TYPE_KEY = 'nr.syntheticsType'
       SYNTHETICS_INITIATOR_KEY = 'nr.syntheticsInitiator'
       SYNTHETICS_KEY_PREFIX = 'nr.synthetics'
-      PRIORITY_KEY = 'priority'.freeze
-      SPAN_ID_KEY = 'spanId'.freeze
+      PRIORITY_KEY = 'priority'
+      SPAN_ID_KEY = 'spanId'
+      GUID_KEY = 'guid'
 
       SYNTHETICS_PAYLOAD_EXPECTED = [:synthetics_resource_id, :synthetics_job_id, :synthetics_monitor_id, :synthetics_type, :synthetics_initiator]
 
@@ -57,7 +58,10 @@ module NewRelic
         }
 
         attrs[SPAN_ID_KEY] = span_id if span_id
+        # don't use safe navigation - leave off keys with missing values
+        # instead of using nil
         attrs[PORT_KEY] = noticed_error.request_port if noticed_error.request_port
+        attrs[GUID_KEY] = noticed_error.transaction_id if noticed_error.transaction_id
 
         if payload
           attrs[NAME_KEY] = payload[:name]
@@ -93,8 +97,8 @@ module NewRelic
       end
 
       def append_cat(payload, sample)
-        sample[GUID_KEY] = payload[:guid] if payload[:guid]
-        sample[REFERRING_TRANSACTION_GUID_KEY] = payload[:referring_transaction_guid] if payload[:referring_transaction_guid]
+        sample[CAT_GUID_KEY] = payload[:guid] if payload[:guid]
+        sample[CAT_REFERRING_TRANSACTION_GUID_KEY] = payload[:referring_transaction_guid] if payload[:referring_transaction_guid]
       end
     end
   end

data/lib/new_relic/agent.rb

@@ -64,6 +64,7 @@ module NewRelic
     require 'new_relic/agent/linking_metadata'
     require 'new_relic/agent/local_log_decorator'
     require 'new_relic/agent/llm'
+    require 'new_relic/agent/aws'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -709,16 +710,19 @@ module NewRelic
     def add_custom_attributes(params) # THREAD_LOCAL_ACCESS
       record_api_supportability_metric(:add_custom_attributes)
 
-      if params.is_a?(Hash)
-        Transaction.tl_current&.add_custom_attributes(params)
-
-        segment = ::NewRelic::Agent::Tracer.current_segment
-        if segment
-          add_new_segment_attributes(params, segment)
-        end
-      else
+      unless params.is_a?(Hash)
         ::NewRelic::Agent.logger.warn("Bad argument passed to #add_custom_attributes. Expected Hash but got #{params.class}")
+        return
       end
+
+      if NewRelic::Agent.agent&.serverless?
+        ::NewRelic::Agent.logger.warn('Custom attributes are not supported in serverless mode')
+        return
+      end
+
+      Transaction.tl_current&.add_custom_attributes(params)
+      segment = ::NewRelic::Agent::Tracer.current_segment
+      add_new_segment_attributes(params, segment) if segment
     end
 
     def add_new_segment_attributes(params, segment)