newrelic_rpm 3.12.0.288 → 9.10.2

data/lib/new_relic/agent/transaction_error_primitive.rb

@@ -0,0 +1,105 @@
+# 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
+
+# This module was introduced and largely extracted from the transaction event aggregator
+# when the synthetics container was extracted from it. Its purpose is to create the data
+# necessary for creating a transaction event and to facilitate transfer of events between
+# the transaction event aggregator and the synthetics container.
+
+require 'new_relic/agent/payload_metric_mapping'
+require 'new_relic/agent/distributed_tracing/distributed_trace_payload'
+require 'new_relic/agent/distributed_tracing/distributed_trace_attributes'
+
+module NewRelic
+  module Agent
+    module TransactionErrorPrimitive
+      extend self
+
+      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'
+      SPAN_ID_KEY = 'spanId'
+      GUID_KEY = 'guid'
+
+      SYNTHETICS_PAYLOAD_EXPECTED = [:synthetics_resource_id, :synthetics_job_id, :synthetics_monitor_id, :synthetics_type, :synthetics_initiator]
+
+      def create(noticed_error, payload, span_id)
+        [
+          intrinsic_attributes_for(noticed_error, payload, span_id),
+          noticed_error.custom_attributes,
+          noticed_error.agent_attributes
+        ]
+      end
+
+      def intrinsic_attributes_for(noticed_error, payload, span_id)
+        attrs = {
+          TYPE_KEY => SAMPLE_TYPE,
+          ERROR_CLASS_KEY => noticed_error.exception_class_name,
+          ERROR_MESSAGE_KEY => noticed_error.message,
+          ERROR_EXPECTED_KEY => noticed_error.expected,
+          TIMESTAMP_KEY => noticed_error.timestamp.to_f
+        }
+
+        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]
+          attrs[DURATION_KEY] = payload[:duration]
+          attrs[SAMPLED_KEY] = payload[:sampled] if payload.key?(:sampled)
+          attrs[PRIORITY_KEY] = payload[:priority]
+          append_synthetics(payload, attrs)
+          append_cat(payload, attrs)
+          DistributedTraceAttributes.copy_to_hash(payload, attrs)
+          PayloadMetricMapping.append_mapped_metrics(payload[:metrics], attrs)
+        else
+          attrs[PRIORITY_KEY] = rand.round(NewRelic::PRIORITY_PRECISION)
+        end
+
+        attrs
+      end
+
+      def append_synthetics(payload, sample)
+        return unless payload[:synthetics_job_id]
+
+        sample[SYNTHETICS_RESOURCE_ID_KEY] = payload[:synthetics_resource_id] if payload[:synthetics_resource_id]
+        sample[SYNTHETICS_JOB_ID_KEY] = payload[:synthetics_job_id] if payload[:synthetics_job_id]
+        sample[SYNTHETICS_MONITOR_ID_KEY] = payload[:synthetics_monitor_id] if payload[:synthetics_monitor_id]
+        sample[SYNTHETICS_TYPE_KEY] = payload[:synthetics_type] if payload[:synthetics_type]
+        sample[SYNTHETICS_INITIATOR_KEY] = payload[:synthetics_initiator] if payload[:synthetics_initiator]
+
+        payload.each do |k, v|
+          next unless k.to_s.start_with?('synthetics_') && !SYNTHETICS_PAYLOAD_EXPECTED.include?(k)
+
+          new_key = SYNTHETICS_KEY_PREFIX + NewRelic::LanguageSupport.camelize(k.to_s.gsub('synthetics_', ''))
+          sample[new_key] = v
+        end
+      end
+
+      def append_cat(payload, sample)
+        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
+end

data/lib/new_relic/agent/transaction_event_aggregator.rb

@@ -1,273 +1,56 @@
 # -*- ruby -*-
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'monitor'
-
-require 'newrelic_rpm' unless defined?( NewRelic )
-require 'new_relic/agent' unless defined?( NewRelic::Agent )
-
-class NewRelic::Agent::TransactionEventAggregator
-  include NewRelic::Coerce,
-          MonitorMixin
-
-  # The type field of the sample
-  SAMPLE_TYPE              = 'Transaction'.freeze
-
-  # Strings for static keys of the sample structure
-  TYPE_KEY                       = 'type'.freeze
-  TIMESTAMP_KEY                  = 'timestamp'.freeze
-  NAME_KEY                       = 'name'.freeze
-  DURATION_KEY                   = 'duration'.freeze
-  HTTP_RESPONSE_CODE_KEY         = 'httpResponseCode'.freeze
-  GUID_KEY                       = 'nr.guid'.freeze
-  REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'.freeze
-  CAT_TRIP_ID_KEY                = 'nr.tripId'.freeze
-  CAT_PATH_HASH_KEY              = 'nr.pathHash'.freeze
-  CAT_REFERRING_PATH_HASH_KEY    = 'nr.referringPathHash'.freeze
-  CAT_ALTERNATE_PATH_HASHES_KEY  = 'nr.alternatePathHashes'.freeze
-  APDEX_PERF_ZONE_KEY            = 'nr.apdexPerfZone'.freeze
-  SYNTHETICS_RESOURCE_ID_KEY     = "nr.syntheticsResourceId".freeze
-  SYNTHETICS_JOB_ID_KEY          = "nr.syntheticsJobId".freeze
-  SYNTHETICS_MONITOR_ID_KEY      = "nr.syntheticsMonitorId".freeze
-
-  # To avoid allocations when we have empty custom or agent attributes
-  EMPTY_HASH = {}.freeze
-
-  def initialize( event_listener )
-    super()
-
-    @enabled       = false
-    @notified_full = false
-
-    @samples            = ::NewRelic::Agent::SampledBuffer.new(NewRelic::Agent.config[:'analytics_events.max_samples_stored'])
-    @synthetics_samples = ::NewRelic::Agent::SyntheticsEventBuffer.new(NewRelic::Agent.config[:'synthetics.events_limit'])
-
-    event_listener.subscribe( :transaction_finished, &method(:on_transaction_finished) )
-    self.register_config_callbacks
-  end
-
-
-  ######
-  public
-  ######
-
-  # Fetch a copy of the sampler's gathered samples. (Synchronized)
-  def samples
-    return self.synchronize { @samples.to_a.concat(@synthetics_samples.to_a) }
-  end
-
-  def reset!
-    sample_count, request_count, synthetics_dropped = 0
-    old_samples = nil
-
-    self.synchronize do
-      sample_count = @samples.size
-      request_count = @samples.num_seen
-
-      synthetics_dropped = @synthetics_samples.num_dropped
-
-      old_samples = @samples.to_a + @synthetics_samples.to_a
-      @samples.reset!
-      @synthetics_samples.reset!
-
-      @notified_full = false
-    end
-
-    [old_samples, sample_count, request_count, synthetics_dropped]
-  end
-
-  # Clear any existing samples, reset the last sample time, and return the
-  # previous set of samples. (Synchronized)
-  def harvest!
-    old_samples, sample_count, request_count, synthetics_dropped = reset!
-    record_sampling_rate(request_count, sample_count) if @enabled
-    record_dropped_synthetics(synthetics_dropped)
-    old_samples
-  end
-
-  # Merge samples back into the buffer, for example after a failed
-  # transmission to the collector. (Synchronized)
-  def merge!(old_samples)
-    self.synchronize do
-      old_samples.each { |s| append_event(s) }
-    end
-  end
-
-  def record_sampling_rate(request_count, sample_count) #THREAD_LOCAL_ACCESS
-    request_count_lifetime = @samples.seen_lifetime
-    sample_count_lifetime = @samples.captured_lifetime
-    NewRelic::Agent.logger.debug("Sampled %d / %d (%.1f %%) requests this cycle, %d / %d (%.1f %%) since startup" % [
-      sample_count,
-      request_count,
-      (sample_count.to_f / request_count * 100.0),
-      sample_count_lifetime,
-      request_count_lifetime,
-      (sample_count_lifetime.to_f / request_count_lifetime * 100.0)
-    ])
-
-    engine = NewRelic::Agent.instance.stats_engine
-    engine.tl_record_supportability_metric_count("TransactionEventAggregator/requests", request_count)
-    engine.tl_record_supportability_metric_count("TransactionEventAggregator/samples", sample_count)
-  end
-
-  def record_dropped_synthetics(synthetics_dropped)
-    return unless synthetics_dropped > 0
-
-    NewRelic::Agent.logger.debug("Synthetics transaction event limit (#{@samples.capacity}) reached. Further synthetics events this harvest period dropped.")
-
-    engine = NewRelic::Agent.instance.stats_engine
-    engine.tl_record_supportability_metric_count("TransactionEventAggregator/synthetics_events_dropped", synthetics_dropped)
-  end
-
-  def register_config_callbacks
-    NewRelic::Agent.config.register_callback(:'analytics_events.max_samples_stored') do |max_samples|
-      NewRelic::Agent.logger.debug "TransactionEventAggregator max_samples set to #{max_samples}"
-      self.synchronize { @samples.capacity = max_samples }
-    end
-
-    NewRelic::Agent.config.register_callback(:'synthetics.events_limit') do |max_samples|
-      NewRelic::Agent.logger.debug "TransactionEventAggregator limit for synthetics events set to #{max_samples}"
-      self.synchronize { @synthetics_samples.capacity = max_samples }
-    end
-
-    NewRelic::Agent.config.register_callback(:'analytics_events.enabled') do |enabled|
-      @enabled = enabled
-    end
-  end
-
-  def notify_full
-    NewRelic::Agent.logger.debug "Transaction event capacity of #{@samples.capacity} reached, beginning sampling"
-    @notified_full = true
-  end
-
-  # Event handler for the :transaction_finished event.
-  def on_transaction_finished(payload)
-    return unless @enabled
-
-    attributes = payload[:attributes]
-    main_event = create_main_event(payload)
-    custom_attributes = create_custom_attributes(attributes)
-    agent_attributes  = create_agent_attributes(attributes)
-
-    self.synchronize { append_event([main_event, custom_attributes, agent_attributes]) }
-    notify_full if !@notified_full && @samples.full?
-  end
-
-  def append_event(event)
-    main_event, _ = event
-
-    if main_event.include?(SYNTHETICS_RESOURCE_ID_KEY)
-      # Try adding to synthetics buffer. If anything is rejected, give it a
-      # shot in the main transaction events (where it may get sampled)
-      result, rejected = @synthetics_samples.append_with_reject(event)
-
-      if rejected
-        @samples.append(rejected)
-      end
-    else
-      @samples.append(event)
-    end
-  end
-
-  def self.map_metric(metric_name, to_add={})
-    to_add.values.each(&:freeze)
-
-    mappings = OVERVIEW_SPECS.fetch(metric_name, {})
-    mappings.merge!(to_add)
-
-    OVERVIEW_SPECS[metric_name] = mappings
-  end
-
-  OVERVIEW_SPECS = {}
-
-  # All Transactions
-  # Don't need to use the transaction-type specific metrics since this is
-  # scoped to just one transaction, so Datastore/all has what we want.
-  map_metric('Datastore/all',         :total_call_time => "databaseDuration")
-  map_metric('Datastore/all',         :call_count      => "databaseCallCount")
-  map_metric('GC/Transaction/all',    :total_call_time => "gcCumulative")
-
-  # Web Metrics
-  map_metric('WebFrontend/QueueTime', :total_call_time => "queueDuration")
-  map_metric('External/allWeb',       :total_call_time => "externalDuration")
-  map_metric('External/allWeb',       :call_count      => "externalCallCount")
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'newrelic_rpm' unless defined?(NewRelic)
+require 'new_relic/agent' unless defined?(NewRelic::Agent)
+require 'new_relic/agent/event_aggregator'
+require 'new_relic/agent/priority_sampled_buffer'
+
+module NewRelic
+  module Agent
+    class TransactionEventAggregator < EventAggregator
+      named :TransactionEventAggregator
+      capacity_key :'transaction_events.max_samples_stored'
+      enabled_key :'transaction_events.enabled'
+      buffer_class PrioritySampledBuffer
+
+      def record(priority: nil, event: nil, &blk)
+        unless event || priority && blk
+          raise ArgumentError, 'Expected priority and block, or event'
+        end
 
-  # Background Metrics
-  map_metric('External/allOther',     :total_call_time => "externalDuration")
-  map_metric('External/allOther',     :call_count      => "externalCallCount")
+        return unless enabled?
 
-  def append_metrics(txn_metrics, sample)
-    if txn_metrics
-      OVERVIEW_SPECS.each do |(name, extracted_values)|
-        if txn_metrics.has_key?(name)
-          stat = txn_metrics[name]
-          extracted_values.each do |value_name, key_name|
-            sample[key_name] = stat.send(value_name)
-          end
+        @lock.synchronize do
+          @buffer.append(priority: priority, event: event, &blk)
+          notify_if_full
         end
       end
-    end
-  end
 
-  def create_main_event(payload)
-    sample = {
-      TIMESTAMP_KEY => float(payload[:start_timestamp]),
-      NAME_KEY      => string(payload[:name]),
-      DURATION_KEY  => float(payload[:duration]),
-      TYPE_KEY      => SAMPLE_TYPE,
-    }
-    append_metrics(payload[:metrics], sample)
-    optionally_append(GUID_KEY,                       :guid, sample, payload)
-    optionally_append(REFERRING_TRANSACTION_GUID_KEY, :referring_transaction_guid, sample, payload)
-    optionally_append(CAT_TRIP_ID_KEY,                :cat_trip_id, sample, payload)
-    optionally_append(CAT_PATH_HASH_KEY,              :cat_path_hash, sample, payload)
-    optionally_append(CAT_REFERRING_PATH_HASH_KEY,    :cat_referring_path_hash, sample, payload)
-    optionally_append(APDEX_PERF_ZONE_KEY,            :apdex_perf_zone, sample, payload)
-    optionally_append(SYNTHETICS_RESOURCE_ID_KEY,     :synthetics_resource_id, sample, payload)
-    optionally_append(SYNTHETICS_JOB_ID_KEY,          :synthetics_job_id, sample, payload)
-    optionally_append(SYNTHETICS_MONITOR_ID_KEY,      :synthetics_monitor_id, sample, payload)
-    append_http_response_code(sample, payload)
-    append_cat_alternate_path_hashes(sample, payload)
-    sample
-  end
+      private
 
-  def append_http_response_code(sample, payload)
-    unless NewRelic::Agent.config[:disable_middleware_instrumentation]
-      optionally_append(HTTP_RESPONSE_CODE_KEY, :http_response_code, sample, payload)
-    end
-  end
+      def after_harvest(metadata)
+        return unless enabled?
 
-  def append_cat_alternate_path_hashes(sample, payload)
-    if payload.include?(:cat_alternate_path_hashes)
-      sample[CAT_ALTERNATE_PATH_HASHES_KEY] = payload[:cat_alternate_path_hashes].sort.join(',')
-    end
-  end
-
-  def optionally_append(sample_key, payload_key, sample, payload)
-    if payload.include?(payload_key)
-      sample[sample_key] = string(payload[payload_key])
-    end
-  end
-
-  def create_custom_attributes(attributes)
-    if attributes
-      custom_attributes = attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS)
-      custom_attributes = custom_attributes
-      custom_attributes.freeze
-    else
-      EMPTY_HASH
-    end
-  end
+        record_sampling_rate(metadata)
+      end
 
-  def create_agent_attributes(attributes)
-    if attributes
-      agent_attributes = attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS)
-      agent_attributes = agent_attributes
-      agent_attributes.freeze
-    else
-      EMPTY_HASH
+      def record_sampling_rate(metadata) # THREAD_LOCAL_ACCESS
+        NewRelic::Agent.logger.debug('Sampled %d / %d (%.1f %%) requests this cycle, %d / %d (%.1f %%) since startup' % [
+          metadata[:captured],
+          metadata[:seen],
+          (metadata[:captured].to_f / metadata[:seen] * 100.0),
+          metadata[:captured_lifetime],
+          metadata[:seen_lifetime],
+          (metadata[:captured_lifetime].to_f / metadata[:seen_lifetime] * 100.0)
+        ])
+
+        engine = NewRelic::Agent.instance.stats_engine
+        engine.tl_record_supportability_metric_count('TransactionEventAggregator/requests', metadata[:seen])
+        engine.tl_record_supportability_metric_count('TransactionEventAggregator/samples', metadata[:captured])
+      end
     end
   end
 end

data/lib/new_relic/agent/transaction_event_primitive.rb

@@ -0,0 +1,127 @@
+# 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
+
+# This module was introduced and largely extracted from the transaction event aggregator
+# when the synthetics container was extracted from it. Its purpose is to create the data
+# necessary for creating a transaction event and to facilitate transfer of events between
+# the transaction event aggregator and the synthetics container.
+
+require 'new_relic/agent/payload_metric_mapping'
+require 'new_relic/agent/distributed_tracing/distributed_trace_attributes'
+
+module NewRelic
+  module Agent
+    module TransactionEventPrimitive
+      include NewRelic::Coerce
+      extend self
+
+      COMMA = ','
+
+      # The type field of the sample
+      SAMPLE_TYPE = 'Transaction'
+
+      # Strings for static keys of the sample structure
+      TYPE_KEY = 'type'
+      TIMESTAMP_KEY = 'timestamp'
+      NAME_KEY = 'name'
+      DURATION_KEY = 'duration'
+      ERROR_KEY = 'error'
+      SAMPLED_KEY = 'sampled'
+      PRIORITY_KEY = 'priority'
+      GUID_KEY = 'nr.guid'
+      REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'
+      CAT_PATH_HASH_KEY = 'nr.pathHash'
+      CAT_REFERRING_PATH_HASH_KEY = 'nr.referringPathHash'
+      CAT_ALTERNATE_PATH_HASHES_KEY = 'nr.alternatePathHashes'
+      APDEX_PERF_ZONE_KEY = 'nr.apdexPerfZone'
+      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'
+
+      SYNTHETICS_PAYLOAD_EXPECTED = [:synthetics_resource_id, :synthetics_job_id, :synthetics_monitor_id, :synthetics_type, :synthetics_initiator]
+
+      def create(payload)
+        intrinsics = {
+          TIMESTAMP_KEY => float(payload[:start_timestamp]),
+          NAME_KEY => string(payload[:name]),
+          DURATION_KEY => float(payload[:duration]),
+          TYPE_KEY => SAMPLE_TYPE,
+          ERROR_KEY => payload[:error],
+          PRIORITY_KEY => payload[:priority]
+        }
+
+        intrinsics[SAMPLED_KEY] = payload[:sampled] if payload.key?(:sampled)
+
+        PayloadMetricMapping.append_mapped_metrics(payload[:metrics], intrinsics)
+        append_optional_attributes(intrinsics, payload)
+        DistributedTraceAttributes.copy_to_hash(payload, intrinsics)
+
+        attributes = payload[:attributes]
+
+        [intrinsics, custom_attributes(attributes), agent_attributes(attributes)]
+      end
+
+      private
+
+      def append_optional_attributes(sample, payload)
+        optionally_append(GUID_KEY, :guid, sample, payload)
+        optionally_append(REFERRING_TRANSACTION_GUID_KEY, :referring_transaction_guid, sample, payload)
+        optionally_append(CAT_PATH_HASH_KEY, :cat_path_hash, sample, payload)
+        optionally_append(CAT_REFERRING_PATH_HASH_KEY, :cat_referring_path_hash, sample, payload)
+        optionally_append(APDEX_PERF_ZONE_KEY, :apdex_perf_zone, sample, payload)
+        optionally_append(SYNTHETICS_RESOURCE_ID_KEY, :synthetics_resource_id, sample, payload)
+        optionally_append(SYNTHETICS_JOB_ID_KEY, :synthetics_job_id, sample, payload)
+        optionally_append(SYNTHETICS_MONITOR_ID_KEY, :synthetics_monitor_id, sample, payload)
+        optionally_append(SYNTHETICS_TYPE_KEY, :synthetics_type, sample, payload)
+        optionally_append(SYNTHETICS_INITIATOR_KEY, :synthetics_initiator, sample, payload)
+        append_synthetics_info_attributes(sample, payload)
+        append_cat_alternate_path_hashes(sample, payload)
+      end
+
+      def append_synthetics_info_attributes(sample, payload)
+        return unless payload.include?(:synthetics_job_id)
+
+        payload.each do |k, v|
+          next unless k.to_s.start_with?('synthetics_') && !SYNTHETICS_PAYLOAD_EXPECTED.include?(k)
+
+          new_key = SYNTHETICS_KEY_PREFIX + NewRelic::LanguageSupport.camelize(k.to_s.gsub('synthetics_', ''))
+          sample[new_key] = v.to_s
+        end
+      end
+
+      def append_cat_alternate_path_hashes(sample, payload)
+        if payload.include?(:cat_alternate_path_hashes)
+          sample[CAT_ALTERNATE_PATH_HASHES_KEY] = payload[:cat_alternate_path_hashes].sort.join(COMMA)
+        end
+      end
+
+      def optionally_append(sample_key, payload_key, sample, payload)
+        if payload.include?(payload_key)
+          sample[sample_key] = string(payload[payload_key])
+        end
+      end
+
+      def custom_attributes(attributes)
+        if attributes
+          result = attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_EVENTS)
+          result.freeze
+        else
+          NewRelic::EMPTY_HASH
+        end
+      end
+
+      def agent_attributes(attributes)
+        if attributes
+          result = attributes.agent_attributes_for(AttributeFilter::DST_TRANSACTION_EVENTS)
+          result.freeze
+        else
+          NewRelic::EMPTY_HASH
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction_event_recorder.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 'new_relic/agent/transaction_event_aggregator'
+require 'new_relic/agent/synthetics_event_aggregator'
+require 'new_relic/agent/transaction_event_primitive'
+
+module NewRelic
+  module Agent
+    # This is responsible for recording transaction events and managing
+    # the relationship between events generated from synthetics requests
+    # vs normal requests.
+    class TransactionEventRecorder
+      attr_reader :transaction_event_aggregator
+      attr_reader :synthetics_event_aggregator
+
+      def initialize(events)
+        @transaction_event_aggregator = NewRelic::Agent::TransactionEventAggregator.new(events)
+        @synthetics_event_aggregator = NewRelic::Agent::SyntheticsEventAggregator.new(events)
+      end
+
+      def record(payload)
+        return unless NewRelic::Agent.config[:'transaction_events.enabled']
+
+        if synthetics_event?(payload)
+          event = create_event(payload)
+          result = synthetics_event_aggregator.record(event)
+          transaction_event_aggregator.record(event: event) if result.nil?
+        else
+          transaction_event_aggregator.record(priority: payload[:priority]) { create_event(payload) }
+        end
+      end
+
+      def create_event(payload)
+        TransactionEventPrimitive.create(payload)
+      end
+
+      def synthetics_event?(payload)
+        payload.key?(:synthetics_resource_id)
+      end
+
+      def drop_buffered_data
+        transaction_event_aggregator.reset!
+        synthetics_event_aggregator.reset!
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction_metrics.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # This class represents a set of metrics that were recorded during a single
 # transaction. Since the name of the transaction is not known until its end, we
@@ -10,18 +10,27 @@
 module NewRelic
   module Agent
     class TransactionMetrics
-      DEFAULT_PROC = Proc.new { |hash, name| hash[name] = NewRelic::Agent::Stats.new }
+      DEFAULT_PROC = proc { |hash, name| hash[name] = NewRelic::Agent::Stats.new }
 
       def initialize
+        @lock = Mutex.new
         @unscoped = Hash.new(&DEFAULT_PROC)
-        @scoped   = Hash.new(&DEFAULT_PROC)
+        @scoped = Hash.new(&DEFAULT_PROC)
       end
 
-      def record_scoped(names, value=nil, aux=nil, &blk)
+      # As a general rule, when recording a scoped metric, the corresponding
+      # unscoped metric should always be recorded as well.
+      #
+      # As an optimization, scoped metrics are representated within this class
+      # only by their entries in the @scoped Hash, and it's up to clients to
+      # propagate them into unscoped metrics as well when instances of this
+      # class are merged into the global metric store.
+      #
+      def record_scoped_and_unscoped(names, value = nil, aux = nil, &blk)
         _record_metrics(names, value, aux, @scoped, &blk)
       end
 
-      def record_unscoped(names, value=nil, aux=nil, &blk)
+      def record_unscoped(names, value = nil, aux = nil, &blk)
         _record_metrics(names, value, aux, @unscoped, &blk)
       end
 
@@ -34,11 +43,11 @@ module NewRelic
       end
 
       def each_unscoped
-        @unscoped.each { |name, stats| yield name, stats }
+        @lock.synchronize { @unscoped.each { |name, stats| yield(name, stats) } }
       end
 
       def each_scoped
-        @scoped.each { |name, stats| yield name, stats }
+        @lock.synchronize { @scoped.each { |name, stats| yield(name, stats) } }
       end
 
       def _record_metrics(names, value, aux, target, &blk)
@@ -46,10 +55,10 @@ module NewRelic
         case names
         when Array
           names.each do |name|
-            target[name].record(value, aux, &blk)
+            @lock.synchronize { target[name].record(value, aux, &blk) }
           end
         else
-          target[names].record(value, aux, &blk)
+          @lock.synchronize { target[names].record(value, aux, &blk) }
         end
       end
     end