newrelic_rpm 3.14.1.311 → 3.14.2.312

data/test/new_relic/agent/transaction/request_attributes_test.rb

@@ -17,6 +17,7 @@ module NewRelic
           assert_equal "/", attrs.request_path
           assert_nil attrs.referer
           assert_nil attrs.content_length
+          assert_nil attrs.content_type
           assert_nil attrs.host
           assert_nil attrs.user_agent
           assert_nil attrs.request_method
@@ -43,6 +44,13 @@ module NewRelic
           assert_equal 111, attrs.content_length
         end
 
+        def test_sets_content_type_from_request
+          request = stub 'request', :content_type => "application/json"
+          attrs = RequestAttributes.new request
+
+          assert_equal "application/json", attrs.content_type
+        end
+
         def test_sets_host_from_request
           request = stub 'request', :host => "localhost"
           attrs = RequestAttributes.new request

data/test/new_relic/agent/transaction_error_primitive_test.rb

@@ -0,0 +1,117 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/attribute_filter'
+require 'new_relic/agent/transaction/attributes'
+require 'new_relic/agent/transaction_error_primitive'
+
+module NewRelic
+  module Agent
+    class TransactionErrorPrimitiveTest < Minitest::Test
+      def setup
+        freeze_time
+      end
+
+
+      def test_event_includes_expected_intrinsics
+        intrinsics, *_ = create_event
+
+        assert_equal 'TransactionError', intrinsics['type']
+        assert_in_delta Time.now.to_f, intrinsics['timestamp'], 0.001
+        assert_equal "RuntimeError", intrinsics['error.class']
+        assert_equal "Big Controller!", intrinsics['error.message']
+        assert_equal "Controller/blogs/index", intrinsics['transactionName']
+        assert_equal 0.1, intrinsics['duration']
+        assert_equal 80, intrinsics['port']
+      end
+
+      def test_event_includes_synthetics
+        intrinsics, *_ = create_event :payload_options => {
+          :synthetics_resource_id=>3,
+          :synthetics_job_id=>4,
+          :synthetics_monitor_id=>5
+        }
+
+        assert_equal 3, intrinsics['nr.syntheticsResourceId']
+        assert_equal 4, intrinsics['nr.syntheticsJobId']
+        assert_equal 5, intrinsics['nr.syntheticsMonitorId']
+      end
+
+      def test_includes_mapped_metrics
+        metrics = NewRelic::Agent::TransactionMetrics.new
+        metrics.record_unscoped 'Datastore/all', 10
+        metrics.record_unscoped 'GC/Transaction/all', 11
+        metrics.record_unscoped 'WebFrontend/QueueTime', 12
+        metrics.record_unscoped 'External/allWeb', 13
+
+        intrinsics, *_ = create_event :payload_options => {:metrics => metrics}
+
+        assert_equal 10.0, intrinsics["databaseDuration"]
+        assert_equal 1, intrinsics["databaseCallCount"]
+        assert_equal 11.0, intrinsics["gcCumulative"]
+        assert_equal 12.0, intrinsics["queueDuration"]
+        assert_equal 13.0, intrinsics["externalDuration"]
+        assert_equal 1, intrinsics["externalCallCount"]
+      end
+
+      def test_includes_cat_attributes
+        intrinsics, *_ = create_event :payload_options => {:guid => "GUID", :referring_transaction_guid=>"REFERRING_GUID"}
+
+        assert_equal "GUID", intrinsics["nr.transactionGuid"]
+        assert_equal "REFERRING_GUID", intrinsics["nr.referringTransactionGuid"]
+      end
+
+      def test_includes_custom_attributes
+        attrs = {"user" => "Wes Mantooth", "channel" => 9}
+
+        attributes = Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
+        attributes.merge_custom_attributes attrs
+
+        _, custom_attrs, _ = create_event :error_options => {:attributes => attributes}
+
+        assert_equal attrs, custom_attrs
+      end
+
+      def test_includes_agent_attributes
+        attributes = Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
+        attributes.add_agent_attribute :'request.headers.referer', "http://blog.site/home", AttributeFilter::DST_ERROR_COLLECTOR
+        attributes.add_agent_attribute :httpResponseCode, "200", AttributeFilter::DST_ERROR_COLLECTOR
+
+        _, _, agent_attrs = create_event :error_options => {:attributes => attributes}
+
+        expected = {:"request.headers.referer" => "http://blog.site/home", :httpResponseCode => "200"}
+        assert_equal expected, agent_attrs
+      end
+
+      def create_event options = {}
+        payload = generate_payload options[:payload_options] || {}
+        error = create_noticed_error options[:error_options] || {}
+        TransactionErrorPrimitive.create error, payload
+      end
+
+      def generate_payload options = {}
+        {
+          :name => "Controller/blogs/index",
+          :type => :controller,
+          :start_timestamp => Time.now.to_f,
+          :duration => 0.1
+        }.update(options)
+      end
+
+      def create_noticed_error options = {}
+        exception = options.delete(:exception) || RuntimeError.new("Big Controller!")
+        txn_name = "Controller/blogs/index"
+        noticed_error = NewRelic::NoticedError.new(txn_name, exception)
+        noticed_error.request_uri = "http://site.com/blogs"
+        noticed_error.request_port = 80
+        noticed_error.attributes  = options.delete(:attributes)
+        noticed_error.attributes_from_notice_error = options.delete(:custom_params) || {}
+        noticed_error.attributes_from_notice_error.merge!(options)
+
+        noticed_error
+      end
+    end
+  end
+end

data/test/new_relic/agent/transaction_event_aggregator_test.rb

@@ -7,431 +7,205 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 require File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
 require 'new_relic/agent/transaction_event_aggregator'
 require 'new_relic/agent/transaction/attributes'
+require 'new_relic/agent/transaction_event_primitive'
 
-class NewRelic::Agent::TransactionEventAggregatorTest < Minitest::Test
+module NewRelic
+  module Agent
+    class TransactionEventAggregatorTest < Minitest::Test
 
-  def setup
-    freeze_time
-    @event_listener = NewRelic::Agent::EventListener.new
-    @event_aggregator = NewRelic::Agent::TransactionEventAggregator.new(@event_listener)
+      def setup
+        freeze_time
+        @event_aggregator = TransactionEventAggregator.new
 
-    @attributes = nil
-  end
-
-  # Helpers for DataContainerTests
-
-  def create_container
-    @event_aggregator
-  end
-
-  def populate_container(sampler, n)
-    n.times do |i|
-      generate_request("whatever#{i}")
-    end
-  end
-
-  include NewRelic::DataContainerTests
-
-  # Tests
-
-  def test_samples_on_transaction_finished_event
-    with_sampler_config do
-      generate_request
-      assert_equal 1, @event_aggregator.samples.length
-    end
-  end
-
-  EVENT_DATA_INDEX = 0
-  CUSTOM_ATTRIBUTES_INDEX = 1
-  AGENT_ATTRIBUTES_INDEX = 2
-
-  def test_custom_attributes_in_event_are_normalized_to_string_keys
-    with_sampler_config do
-      attributes.merge_custom_attributes(:bing => 2, 1 => 3)
-      generate_request('whatever')
-
-      result = captured_transaction_event[CUSTOM_ATTRIBUTES_INDEX]
-      assert_equal 2, result['bing']
-      assert_equal 3, result['1']
-    end
-  end
-
-  def test_agent_attributes_in_event_are_normalized_to_string_keys
-    with_sampler_config do
-      attributes.add_agent_attribute(:yahoo, 7, NewRelic::Agent::AttributeFilter::DST_ALL)
-      attributes.add_agent_attribute(4, 2, NewRelic::Agent::AttributeFilter::DST_ALL)
-      generate_request('puce')
-
-      result = captured_transaction_event[AGENT_ATTRIBUTES_INDEX]
-      assert_equal 7, result[:yahoo]
-      assert_equal 2, result[4]
-    end
-  end
-
-  def test_error_is_included_in_event_data
-    with_sampler_config do
-      generate_request('whatever', :error => true)
-
-      event_data, *_ = captured_transaction_event
-
-      assert event_data['error']
-    end
-  end
-
-  def test_includes_custom_attributes_in_event
-    with_sampler_config do
-      attributes.merge_custom_attributes('bing' => 2)
-      generate_request('whatever')
-
-      custom_attrs = captured_transaction_event[CUSTOM_ATTRIBUTES_INDEX]
-      assert_equal 2, custom_attrs['bing']
-    end
-  end
-
-  def test_includes_agent_attributes_in_event
-    with_sampler_config do
-      attributes.add_agent_attribute('bing', 2, NewRelic::Agent::AttributeFilter::DST_ALL)
-      generate_request('whatever')
-
-      agent_attrs = captured_transaction_event[AGENT_ATTRIBUTES_INDEX]
-      assert_equal 2, agent_attrs['bing']
-    end
-  end
-
-  def test_doesnt_include_custom_attributes_in_event_when_configured_not_to
-    with_sampler_config('transaction_events.attributes.enabled' => false) do
-      attributes.merge_custom_attributes('bing' => 2)
-      generate_request('whatever')
-
-      custom_attrs = captured_transaction_event[CUSTOM_ATTRIBUTES_INDEX]
-      assert_empty custom_attrs
-    end
-  end
-
-  def test_doesnt_include_agent_attributes_in_event_when_configured_not_to
-    with_sampler_config('transaction_events.attributes.enabled' => false) do
-      attributes.add_agent_attribute('bing', 2, NewRelic::Agent::AttributeFilter::DST_ALL)
-      generate_request('whatever')
-
-      agent_attrs = captured_transaction_event[AGENT_ATTRIBUTES_INDEX]
-      assert_empty agent_attrs
-    end
-  end
-
-
-  def test_doesnt_include_custom_attributes_in_event_when_configured_not_to_with_legacy_setting
-    with_sampler_config('analytics_events.capture_attributes' => false) do
-      attributes.merge_custom_attributes('bing' => 2)
-      generate_request('whatever')
-
-      custom_attrs = captured_transaction_event[CUSTOM_ATTRIBUTES_INDEX]
-      assert_empty custom_attrs
-    end
-  end
-
-  def test_doesnt_include_agent_attributes_in_event_when_configured_not_to_with_legacy_setting
-    with_sampler_config('analytics_events.capture_attributes' => false) do
-      attributes.add_agent_attribute('bing', 2, NewRelic::Agent::AttributeFilter::DST_ALL)
-      generate_request('whatever')
-
-      agent_attrs = captured_transaction_event[AGENT_ATTRIBUTES_INDEX]
-      assert_empty agent_attrs
-    end
-  end
+        @attributes = nil
+      end
 
-  def test_custom_attributes_in_event_cant_override_reserved_attributes
-    with_sampler_config do
-      metrics = NewRelic::Agent::TransactionMetrics.new()
-      metrics.record_unscoped('HttpDispatcher', 0.01)
+      # Helpers for DataContainerTests
 
-      attributes.merge_custom_attributes('type' => 'giraffe', 'duration' => 'hippo')
-      generate_request('whatever', :metrics => metrics)
+      def create_container
+        @event_aggregator
+      end
 
-      txn_event = captured_transaction_event[EVENT_DATA_INDEX]
-      assert_equal 'Transaction', txn_event['type']
-      assert_equal 0.1, txn_event['duration']
+      def populate_container(sampler, n)
+        n.times do |i|
+          generate_request("whatever#{i}")
+        end
+      end
 
-      custom_attrs = captured_transaction_event[CUSTOM_ATTRIBUTES_INDEX]
-      assert_equal 'giraffe', custom_attrs['type']
-      assert_equal 'hippo', custom_attrs['duration']
-    end
-  end
+      include NewRelic::DataContainerTests
 
-  def test_samples_on_transaction_finished_event_includes_expected_web_metrics
-    txn_metrics = NewRelic::Agent::TransactionMetrics.new
-    txn_metrics.record_unscoped('WebFrontend/QueueTime', 13)
-    txn_metrics.record_unscoped('External/allWeb',       14)
-    txn_metrics.record_unscoped('Datastore/all',         15)
-    txn_metrics.record_unscoped("GC/Transaction/all",    16)
-
-    with_sampler_config do
-      generate_request('name', :metrics => txn_metrics)
-      event_data = captured_transaction_event[EVENT_DATA_INDEX]
-      assert_equal 13, event_data["queueDuration"]
-      assert_equal 14, event_data["externalDuration"]
-      assert_equal 15, event_data["databaseDuration"]
-      assert_equal 16, event_data["gcCumulative"]
-
-      assert_equal 1, event_data["externalCallCount"]
-      assert_equal 1, event_data["databaseCallCount"]
-    end
-  end
+      # Tests
 
-  def test_samples_on_transaction_finished_includes_expected_background_metrics
-    txn_metrics = NewRelic::Agent::TransactionMetrics.new
-    txn_metrics.record_unscoped('External/allOther',  12)
-    txn_metrics.record_unscoped('Datastore/all',      13)
-    txn_metrics.record_unscoped("GC/Transaction/all", 14)
+      def test_samples_on_transaction_finished_event
+        generate_request
+        assert_equal 1, last_transaction_events.length
+      end
 
-    with_sampler_config do
-      generate_request('name', :metrics => txn_metrics)
+      def test_records_background_tasks
+        generate_request('a', :type => :controller)
+        generate_request('b', :type => :background)
+        assert_equal 2, last_transaction_events.size
+      end
 
-      event_data = captured_transaction_event[EVENT_DATA_INDEX]
-      assert_equal 12, event_data["externalDuration"]
-      assert_equal 13, event_data["databaseDuration"]
-      assert_equal 14, event_data["gcCumulative"]
+      def test_can_disable_sampling_for_analytics
+        with_config( :'analytics_events.enabled' => false ) do
+          generate_request
+          assert last_transaction_events.empty?
+        end
+      end
 
-      assert_equal 1, event_data["databaseCallCount"]
-      assert_equal 1, event_data["externalCallCount"]
-    end
-  end
+      def test_harvest_returns_previous_sample_list
+        5.times { generate_request }
 
-  def test_samples_on_transaction_finished_event_include_apdex_perf_zone
-    with_sampler_config do
-      generate_request('name', :apdex_perf_zone => 'S')
+        _, old_samples = @event_aggregator.harvest!
 
-      event_data = captured_transaction_event[EVENT_DATA_INDEX]
-      assert_equal 'S', event_data['nr.apdexPerfZone']
-    end
-  end
+        assert_equal 5, old_samples.size
+        assert_equal 0, last_transaction_events.size
+      end
 
-  def test_samples_on_transaction_finished_event_includes_guid
-    with_sampler_config do
-      generate_request('name', :guid => "GUID")
-      assert_equal "GUID", captured_transaction_event[EVENT_DATA_INDEX]["nr.guid"]
-    end
-  end
+      def test_merge_merges_samples_back_into_buffer
+        5.times { generate_request }
+        old_samples = @event_aggregator.harvest!
+        5.times { generate_request }
 
-  def test_samples_on_transaction_finished_event_includes_referring_transaction_guid
-    with_sampler_config do
-      generate_request('name', :referring_transaction_guid=> "REFER")
-      assert_equal "REFER", captured_transaction_event[EVENT_DATA_INDEX]["nr.referringTransactionGuid"]
-    end
-  end
+        @event_aggregator.merge!(old_samples)
 
-  def test_records_background_tasks
-    with_sampler_config do
-      generate_request('a', :type => :controller)
-      generate_request('b', :type => :background)
-      assert_equal 2, @event_aggregator.samples.size
-    end
-  end
+        assert_equal(10, last_transaction_events.size)
+      end
 
-  def test_can_disable_sampling_for_analytics
-    with_sampler_config( :'analytics_events.enabled' => false ) do
-      generate_request
-      assert @event_aggregator.samples.empty?
-    end
-  end
+      def test_merge_abides_by_max_samples_limit
+        with_config(:'analytics_events.max_samples_stored' => 5) do
+          4.times { generate_request }
+          old_samples = @event_aggregator.harvest!
+          4.times { generate_request }
 
-  def test_harvest_returns_previous_sample_list
-    with_sampler_config do
-      5.times { generate_request }
+          @event_aggregator.merge!(old_samples)
+          assert_equal(5, last_transaction_events.size)
+        end
+      end
 
-      old_samples = @event_aggregator.harvest!
+      def test_sample_counts_are_correct_after_merge
+        with_config :'analytics_events.max_samples_stored' => 5 do
+          buffer = @event_aggregator.instance_variable_get :@buffer
 
-      assert_equal 5, old_samples.size
-      assert_equal 0, @event_aggregator.samples.size
-    end
-  end
+          4.times { generate_request }
+          last_harvest = @event_aggregator.harvest!
 
-  def test_merge_merges_samples_back_into_buffer
-    with_sampler_config do
-      5.times { generate_request }
-      old_samples = @event_aggregator.harvest!
-      5.times { generate_request }
+          assert_equal 4, buffer.seen_lifetime
+          assert_equal 4, buffer.captured_lifetime
+          assert_equal 4, last_harvest[0][:events_seen]
 
-      @event_aggregator.merge!(old_samples)
-      assert_equal(10, @event_aggregator.samples.size)
-    end
-  end
+          4.times { generate_request }
+          @event_aggregator.merge! last_harvest
 
-  def test_merge_abides_by_max_samples_limit
-    with_sampler_config(:'analytics_events.max_samples_stored' => 5) do
-      4.times { generate_request }
-      old_samples = @event_aggregator.harvest!
-      4.times { generate_request }
+          reservoir_stats, samples = @event_aggregator.harvest!
 
-      @event_aggregator.merge!(old_samples)
-      assert_equal(5, @event_aggregator.samples.size)
-    end
-  end
-
-  def test_limits_total_number_of_samples_to_max_samples_stored
-    with_sampler_config( :'analytics_events.max_samples_stored' => 100 ) do
-      150.times { generate_request }
-      assert_equal 100, @event_aggregator.samples.size
-    end
-  end
-
-  def test_resets_limits_on_harvest
-    with_sampler_config( :'analytics_events.max_samples_stored' => 100 ) do
-      50.times { generate_request('before') }
-      samples_before = @event_aggregator.samples
-      assert_equal 50, samples_before.size
+          assert_equal 5, samples.size
+          assert_equal 8, reservoir_stats[:events_seen]
+          assert_equal 8, buffer.seen_lifetime
+          assert_equal 5, buffer.captured_lifetime
+        end
+      end
 
-      @event_aggregator.harvest!
+      def test_limits_total_number_of_samples_to_max_samples_stored
+        with_config( :'analytics_events.max_samples_stored' => 100 ) do
+          150.times { generate_request }
+          assert_equal 100, last_transaction_events.size
+        end
+      end
 
-      150.times { generate_request('after') }
-      samples_after = @event_aggregator.samples
-      assert_equal 100, samples_after.size
+      def test_resets_limits_on_harvest
+        with_config( :'analytics_events.max_samples_stored' => 100 ) do
+          50.times { generate_request('before') }
+          samples_before = last_transaction_events
+          assert_equal 50, samples_before.size
 
-      assert_equal 0, (samples_before & samples_after).size
-    end
-  end
+          150.times { generate_request('after') }
+          samples_after = last_transaction_events
+          assert_equal 100, samples_after.size
 
-  def test_does_not_drop_samples_when_used_from_multiple_threads
-    with_sampler_config( :'analytics_events.max_samples_stored' => 100 * 100 ) do
-      threads = []
-      25.times do
-        threads << Thread.new do
-          100.times { generate_request }
+          assert_equal 0, (samples_before & samples_after).size
         end
       end
-      threads.each { |t| t.join }
-
-      assert_equal(25 * 100, @event_aggregator.samples.size)
-    end
-  end
 
-  def test_synthetics_aggregation_limits
-    with_sampler_config(:'synthetics.events_limit' => 10,
-                        :'analytics_events.max_samples_stored' => 0) do
-      20.times do
-        generate_request('synthetic', :synthetics_resource_id => 100)
+      def test_does_not_drop_samples_when_used_from_multiple_threads
+        with_config( :'analytics_events.max_samples_stored' => 100 * 100 ) do
+          threads = []
+          25.times do
+            threads << Thread.new do
+              100.times { generate_request }
+            end
+          end
+          threads.each { |t| t.join }
+
+          assert_equal(25 * 100, last_transaction_events.size)
+        end
       end
 
-      assert_equal 10, @event_aggregator.samples.size
-    end
-  end
-
-  def test_synthetics_events_overflow_to_transaction_buffer
-    with_sampler_config(:'synthetics.events_limit' => 10) do
-      20.times do
-        generate_request('synthetic', :synthetics_resource_id => 100)
+      def test_append_accepts_a_block
+        payload = generate_payload
+        @event_aggregator.append { TransactionEventPrimitive.create(payload) }
+        assert_equal 1, last_transaction_events.size
       end
 
-      assert_equal 20, @event_aggregator.samples.size
-    end
-  end
+      def test_block_is_not_executed_unless_buffer_admits_event
+        event = nil
 
-  def test_synthetics_events_kept_by_timestamp
-    with_sampler_config(:'synthetics.events_limit' => 10,
-                        :'analytics_events.max_samples_stored' => 0) do
-      10.times do |i|
-        generate_request('synthetic', :timestamp => i + 10, :synthetics_resource_id => 100)
-      end
+        with_config :'analytics_events.max_samples_stored' => 5 do
+          5.times { generate_request }
 
-      generate_request('synthetic', :timestamp => 1, :synthetics_resource_id => 100)
+          #cause sample to be discarded by the sampled buffer
+          buffer = @event_aggregator.instance_variable_get :@buffer
+          buffer.stubs(:rand).returns(6)
 
-      assert_equal 10, @event_aggregator.samples.size
-      timestamps = @event_aggregator.samples.map do |(main, _)|
-        main["timestamp"]
-      end.sort
-
-      assert_equal ([1] + (10..18).to_a), timestamps
-    end
-  end
+          payload = generate_payload
+          @event_aggregator.append do
+            event = TransactionEventPrimitive.create(payload)
+          end
+        end
 
-  def test_synthetics_events_timestamp_bumps_go_to_main_buffer
-    with_sampler_config(:'synthetics.events_limit' => 10) do
-      10.times do |i|
-        generate_request('synthetic', :timestamp => i + 10, :synthetics_resource_id => 100)
+        assert_nil event, "Did not expect block to be executed"
+        refute_includes last_transaction_events, event
       end
 
-      generate_request('synthetic', :timestamp => 1, :synthetics_resource_id => 100)
+      #
+      # Helpers
+      #
 
-      assert_equal 11, @event_aggregator.samples.size
-    end
-  end
-
-  def test_merging_synthetics_still_applies_limit
-    samples = with_sampler_config(:'synthetics.events_limit' => 20) do
-      20.times do
-        generate_request('synthetic', :synthetics_resource_id => 100)
+      def generate_request(name='whatever', options={})
+        payload = generate_payload name, options
+        @event_aggregator.append TransactionEventPrimitive.create(payload)
       end
-      @event_aggregator.harvest!
-    end
 
-    with_sampler_config(:'synthetics.events_limit' => 10,
-                        :'analytics_events.max_samples_stored' => 0) do
-      @event_aggregator.merge!(samples)
-      assert_equal 10, @event_aggregator.samples.size
-    end
-  end
-
-  def test_synthetics_event_dropped_records_supportability_metrics
-    with_sampler_config(:'synthetics.events_limit' => 20) do
-      20.times do
-        generate_request('synthetic', :synthetics_resource_id => 100)
+      def generate_payload(name='whatever', options={})
+        {
+          :name => "Controller/#{name}",
+          :type => :controller,
+          :start_timestamp => options[:timestamp] || Time.now.to_f,
+          :duration => 0.1,
+          :attributes => attributes,
+          :error => false
+        }.merge(options)
       end
 
-      @event_aggregator.harvest!
-
-      metric = 'Supportability/TransactionEventAggregator/synthetics_events_dropped'
-      assert_metrics_not_recorded(metric)
-    end
-  end
+      def attributes
+        if @attributes.nil?
+          filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
+          @attributes = NewRelic::Agent::Transaction::Attributes.new(filter)
+        end
 
-  def test_synthetics_event_dropped_records_supportability_metrics
-    with_sampler_config(:'synthetics.events_limit' => 10) do
-      20.times do
-        generate_request('synthetic', :synthetics_resource_id => 100)
+        @attributes
       end
 
-      @event_aggregator.harvest!
-
-      metric = 'Supportability/TransactionEventAggregator/synthetics_events_dropped'
-      assert_metrics_recorded(metric => { :call_count => 10 })
-    end
-  end
-
-  #
-  # Helpers
-  #
-
-  def generate_request(name='whatever', options={})
-    payload = {
-      :name => "Controller/#{name}",
-      :type => :controller,
-      :start_timestamp => options[:timestamp] || Time.now.to_f,
-      :duration => 0.1,
-      :attributes => attributes,
-      :error => false
-    }.merge(options)
-    @event_listener.notify(:transaction_finished, payload)
-  end
-
-  def with_sampler_config(options = {})
-    defaults = { :'analytics_events.max_samples_stored' => 100 }
-    defaults.merge!(options)
-    with_config(defaults) do
-      @event_listener.notify( :finished_configuring )
-      yield
-    end
-  end
-
-  def captured_transaction_event
-    assert_equal 1, @event_aggregator.samples.size
-    @event_aggregator.samples.first
-  end
+      def last_transaction_events
+        @event_aggregator.harvest![1]
+      end
 
-  def attributes
-    if @attributes.nil?
-      filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
-      @attributes = NewRelic::Agent::Transaction::Attributes.new(filter)
+      def last_transaction_event
+        events = last_transaction_events
+        assert_equal 1, events.size
+        events.first
+      end
     end
-
-    @attributes
   end
 end