mmtrix_rpm 1.0.0.1

data/test/mmtrix/metric_data_test.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+require 'mmtrix/metric_data'
+class Mmtrix::MetricDataTest < Minitest::Test
+  def test_initialize_basic
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md = Mmtrix::MetricData.new(spec, stats, metric_id)
+    assert_equal spec, md.metric_spec
+    assert_equal stats, md.stats
+    assert_equal metric_id, md.metric_id
+  end
+
+  def test_eql_basic
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = Mmtrix::MetricData.new(spec, stats, metric_id)
+    md2 = Mmtrix::MetricData.new(spec, stats, metric_id)
+    assert(md1.eql?(md2), "The example metric data objects should be eql?: #{md1.inspect} #{md2.inspect}")
+    assert(md2.eql?(md1), "The example metric data objects should be eql?: #{md1.inspect} #{md2.inspect}")
+  end
+
+  def test_eql_unequal_specs
+    spec = mock('metric_spec')
+    other_spec = mock('other_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = Mmtrix::MetricData.new(spec, stats, metric_id)
+    md2 = Mmtrix::MetricData.new(other_spec, stats, metric_id)
+    assert(!md1.eql?(md2), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+  end
+  def test_eql_unequal_stats
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    other_stats = mock('other_stats')
+    metric_id = mock('metric_id')
+    md1 = Mmtrix::MetricData.new(spec, stats, metric_id)
+    md2 = Mmtrix::MetricData.new(spec, other_stats, metric_id)
+    assert(!md1.eql?(md2), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+  end
+
+  def test_eql_unequal_metric_ids_dont_matter
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    other_metric_id = mock('other_metric_id')
+    md1 = Mmtrix::MetricData.new(spec, stats, metric_id)
+    md2 = Mmtrix::MetricData.new(spec, stats, other_metric_id)
+    assert(md1.eql?(md2), "The example metric data objects should be eql? with different metric_ids: #{md1.inspect} #{md2.inspect}")
+    assert(md2.eql?(md1), "The example metric data objects should be eql? with different metric_ids: #{md1.inspect} #{md2.inspect}")
+  end
+
+  def test_original_spec_basic
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = Mmtrix::MetricData.new(spec, stats, metric_id)
+    original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
+    assert_equal(spec, md1.metric_spec, "should return the metric spec for original spec when original spec is nil, but was #{md1.original_spec}")
+  end
+
+  def test_metric_spec_equal_should_not_set_original_spec_with_no_metric_spec
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = Mmtrix::MetricData.new(nil, stats, metric_id)
+    original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
+
+    new_spec = mock('new metric_spec')
+    assert_equal(new_spec, md1.metric_spec=(new_spec), "should return the new spec")
+
+    new_original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, new_original_spec, "should not set @original_spec  but was #{new_original_spec.inspect}")
+  end
+
+  def test_metric_spec_equal_should_set_original_spec_with_existing_metric_spec
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = Mmtrix::MetricData.new(spec, stats, metric_id)
+    original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
+
+    new_spec = mock('new metric_spec')
+    assert_equal(new_spec, md1.metric_spec=(new_spec), "should return the new spec")
+
+    new_original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(spec, new_original_spec, "should set @original_spec to the existing metric_spec  but was #{new_original_spec.inspect}")
+  end
+
+  def test_hash
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = Mmtrix::MetricData.new(spec, stats, metric_id)
+    assert((spec.hash ^ stats.hash) == md1.hash, "expected #{spec.hash ^ stats.hash} to equal #{md1.hash}")
+  end
+
+  if {}.respond_to?(:to_json)
+  def test_to_json_no_metric_id
+    md = Mmtrix::MetricData.new(Mmtrix::MetricSpec.new('Custom/test/method', ''), Mmtrix::Agent::Stats.new, nil)
+    json = md.to_json
+    assert(json.include?('"Custom/test/method"'), "should include the metric spec in the json")
+    assert(json.include?('"metric_id":null}'), "should have a null metric_id")
+  end
+
+  def test_to_json_with_metric_id
+    md = Mmtrix::MetricData.new(Mmtrix::MetricSpec.new('Custom/test/method', ''), Mmtrix::Agent::Stats.new, 12345)
+    assert_equal('{"metric_spec":null,"stats":{"total_exclusive_time":0.0,"min_call_time":0.0,"call_count":0,"sum_of_squares":0.0,"total_call_time":0.0,"max_call_time":0.0},"metric_id":12345}', md.to_json, "should not include the metric spec and should have a metric_id")
+  end
+  else
+    puts "Skipping tests in #{__FILE__} because Hash#to_json not available"
+  end
+
+  def test_to_s_with_metric_spec
+    md = Mmtrix::MetricData.new(Mmtrix::MetricSpec.new('Custom/test/method', ''), Mmtrix::Agent::Stats.new, 12345)
+    assert_equal('Custom/test/method(): [ 0 calls 0.0000s / 0.0000s ex]', md.to_s, "should not include the metric id and should include the metric spec")
+  end
+
+  def test_to_s_without_metric_spec
+    md = Mmtrix::MetricData.new(nil, Mmtrix::Agent::Stats.new, 12345)
+    assert_equal('12345: [ 0 calls 0.0000s / 0.0000s ex]', md.to_s, "should include the metric id and not have a metric spec")
+  end
+
+  def test_to_collector_array_with_spec
+    stats = Mmtrix::Agent::Stats.new
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    md = Mmtrix::MetricData.new(Mmtrix::MetricSpec.new('Custom/test/method', 'scope'),
+                                  stats, nil)
+    expected = [ {'name' => 'Custom/test/method', 'scope' => 'scope'},
+                 [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_spec_and_id
+    stats = Mmtrix::Agent::Stats.new
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    md = Mmtrix::MetricData.new(Mmtrix::MetricSpec.new('Custom/test/method', 'scope'),
+                                  stats, 1234)
+    expected = [ 1234, [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_id
+    stats = Mmtrix::Agent::Stats.new
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    md = Mmtrix::MetricData.new(nil, stats, 1234)
+    expected = [ 1234, [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
+    assert_equal expected, md.to_collector_array
+  end
+
+  # Rationals in metric data? -- https://support.mmtrix.com/tickets/28053
+  def test_to_collector_array_with_rationals
+    stats = Mmtrix::Agent::Stats.new
+    stats.call_count = Rational(1, 1)
+    stats.total_call_time = Rational(2, 1)
+    stats.total_exclusive_time = Rational(3, 1)
+    stats.min_call_time = Rational(4, 1)
+    stats.max_call_time = Rational(5, 1)
+    stats.sum_of_squares = Rational(6, 1)
+
+    md = Mmtrix::MetricData.new(nil, stats, 1234)
+    expected = [1234, [1, 2.0, 3.0, 4.0, 5.0, 6.0]]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_bad_values
+    stats = Mmtrix::Agent::Stats.new
+    stats.call_count = nil
+    stats.total_call_time = "junk"
+    stats.total_exclusive_time = Object.new
+    stats.min_call_time = []
+    stats.max_call_time = {}
+    stats.sum_of_squares = Exception.new("Boo")
+
+    md = Mmtrix::MetricData.new(nil, stats, 1234)
+    expected = [1234, [0, 0, 0, 0, 0, 0]]
+    assert_equal expected, md.to_collector_array
+  end
+end

data/test/mmtrix/metric_parser/metric_parser_test.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'conditional_vendored_metric_parser'
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..', 'test_helper'))
+class Mmtrix::MetricParser::MetricParserTest < Minitest::Test
+  class ::AnApplicationClass
+  end
+
+  def test_metric_parser_does_not_instantiate_non_metric_parsing_classes
+    assert Mmtrix::MetricParser::MetricParser.for_metric_named('AnApplicationClass/Foo/Bar').
+      is_a? Mmtrix::MetricParser::MetricParser
+  end
+
+end

data/test/mmtrix/metric_spec_test.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+class Mmtrix::MetricSpecTest < Minitest::Test
+
+  def test_equal
+    spec1 = Mmtrix::MetricSpec.new('Controller')
+    spec2 = Mmtrix::MetricSpec.new('Controller', nil)
+
+    assert spec1.eql?(Mmtrix::MetricSpec.new('Controller'))
+    assert spec2.eql?(Mmtrix::MetricSpec.new('Controller', nil))
+    assert spec1.eql?(spec2)
+    assert !spec2.eql?(Mmtrix::MetricSpec.new('Controller', '/dude'))
+  end
+
+  define_method(:'test_<=>') do
+    s1 = Mmtrix::MetricSpec.new('ActiveRecord')
+    s2 = Mmtrix::MetricSpec.new('Controller')
+    assert_equal [s1, s2].sort, [s1,s2]
+    assert_equal [s2, s1].sort, [s1,s2]
+
+    s1 = Mmtrix::MetricSpec.new('Controller', nil)
+    s2 = Mmtrix::MetricSpec.new('Controller', 'hap')
+    assert_equal [s2, s1].sort, [s1, s2]
+    assert_equal [s1, s2].sort, [s1, s2]
+
+    s1 = Mmtrix::MetricSpec.new('Controller', 'hap')
+    s2 = Mmtrix::MetricSpec.new('Controller', nil)
+    assert_equal [s2, s1].sort, [s2, s1]
+    assert_equal [s1, s2].sort, [s2, s1]
+
+    s1 = Mmtrix::MetricSpec.new('Controller')
+    s2 = Mmtrix::MetricSpec.new('Controller')
+    assert_equal [s2, s1].sort, [s2, s1] # unchanged due to no sort criteria
+    assert_equal [s1, s2].sort, [s1, s2] # unchanged due to no sort criteria
+
+    s1 = Mmtrix::MetricSpec.new('Controller', nil)
+    s2 = Mmtrix::MetricSpec.new('Controller', nil)
+    assert_equal [s2, s1].sort, [s2, s1] # unchanged due to no sort criteria
+    assert_equal [s1, s2].sort, [s1, s2] # unchanged due to no sort criteria
+  end
+
+  # test to make sure the MetricSpec class can serialize to json
+  if defined?(::ActiveSupport)
+    def test_json
+      spec = Mmtrix::MetricSpec.new("controller", "metric#find")
+
+      import = ::ActiveSupport::JSON.decode(spec.to_json)
+
+      compare_spec(spec, import)
+
+      stats = Mmtrix::Agent::Stats.new
+
+      import = ::ActiveSupport::JSON.decode(stats.to_json)
+
+      compare_stat(stats, import)
+
+      metric_data = Mmtrix::MetricData.new(spec, stats, 10)
+
+      import = ::ActiveSupport::JSON.decode(metric_data.to_json)
+
+      compare_metric_data(metric_data, import)
+    end
+  else
+    puts "Skipping tests in #{__FILE__} because ActiveSupport is unavailable"
+  end
+
+  def test_initialize_truncates_name_and_scope
+    long_name = "a" * 300
+    long_scope = "b" * 300
+    spec = Mmtrix::MetricSpec.new(long_name, long_scope)
+    assert_equal("a" * 255, spec.name, "should have shortened the name")
+    assert_equal("b" * 255, spec.scope, "should have shortened the scope")
+  end
+
+  # These next three tests are here only because rpm_site uses our MetricSpec
+  # class in silly ways (specifically, it passes in non-String values for
+  # name/scope). If we can get rid of those silly usages, we can remove these
+  # tests.
+
+  def test_initialize_can_take_a_nil_name
+    spec = Mmtrix::MetricSpec.new(nil)
+
+    assert_equal('', spec.name)
+    assert_equal('', spec.scope)
+  end
+
+  def test_initialize_can_take_a_non_string_name
+    name  = string_wrapper_class.new("name")
+
+    spec = Mmtrix::MetricSpec.new(name)
+
+    assert_equal('name',  spec.name)
+    assert_equal('',      spec.scope)
+  end
+
+  def test_initialize_can_take_a_non_string_scope
+    name  = "name"
+    scope = string_wrapper_class.new("scope")
+
+    spec = Mmtrix::MetricSpec.new(name, scope)
+
+    assert_equal('name',  spec.name)
+    assert_equal('scope', spec.scope)
+  end
+
+  private
+
+  def string_wrapper_class
+    Class.new do
+      def initialize(value)
+        @value = value
+      end
+
+      def to_s
+        @value
+      end
+    end
+  end
+
+  def compare_spec(spec, import)
+    assert_equal 2, import.length
+    assert_equal spec.name, import['name']
+    assert_equal spec.scope, import['scope']
+  end
+
+  def compare_stat(stats, import)
+    assert_equal 6, import.length
+    assert_equal stats.total_call_time, import['total_call_time']
+    assert_equal stats.max_call_time, import['max_call_time']
+    assert_equal stats.min_call_time, import['min_call_time']
+    assert_equal stats.sum_of_squares, import['sum_of_squares']
+    assert_equal stats.call_count, import['call_count']
+    assert_equal stats.total_exclusive_time, import['total_exclusive_time']
+  end
+
+  def compare_metric_data(metric_data, import)
+    assert_equal 3, import.length
+    assert_equal metric_data.metric_id, import['metric_id']
+    compare_spec(metric_data.metric_spec, import['metric_spec']) unless metric_data.metric_id
+    compare_stat(metric_data.stats, import['stats'])
+  end
+end

data/test/mmtrix/multiverse_helpers.rb

@@ -0,0 +1,283 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "agent_helper"))
+
+class Minitest::Test
+  def after_teardown
+    unfreeze_time
+    super
+  end
+end
+
+module MultiverseHelpers
+
+  #
+  # Agent startup/shutdown
+  #
+  # These are considered to be the standard steps for each test to take.
+  # If your tests do something different, it's important that they clean up
+  # after themselves!
+
+  def self.included(base)
+    base.extend(self)
+  end
+
+  def agent
+    Mmtrix::Agent.instance
+  end
+
+  def setup_and_teardown_agent(opts = {}, &block)
+    define_method(:setup) do
+      setup_agent(opts, &block)
+    end
+
+    define_method(:teardown) do
+      teardown_agent
+    end
+  end
+
+  def setup_agent(opts = {}, &block)
+    ensure_fake_collector unless omit_collector?
+
+    # Give caller a shot to setup before we start
+    # Don't just yield, as that won't necessarily have the intended receiver
+    # (the test case instance itself)
+    self.instance_exec($collector, &block) if block_given? && self.respond_to?(:instance_exec)
+
+    # It's important that this is called after the insance_exec above, so that
+    # test cases have the chance to change settings on the fake collector first
+    start_fake_collector unless omit_collector?
+
+    # If a test not using the multiverse helper runs before us, we might need
+    # to clean up before a test too.
+    Mmtrix::Agent.drop_buffered_data
+
+    trigger_agent_reconnect(opts)
+  end
+
+  def teardown_agent
+    # Put the configs back where they belong....
+    Mmtrix::Agent.config.reset_to_defaults
+
+    # Renaming rules don't get cleared on connect--only appended to
+    Mmtrix::Agent.instance.transaction_rules.clear
+    Mmtrix::Agent.instance.stats_engine.metric_rules.clear
+
+    # Clear out lingering stats we didn't transmit
+    Mmtrix::Agent.drop_buffered_data
+
+    # Clear the error collector's ignore_filter
+    Mmtrix::Agent.instance.error_collector.instance_variable_set(:@ignore_filter, nil)
+
+    # Clean up any thread-local variables starting with 'mmtrix'
+    Mmtrix::Agent::TransactionState.tl_clear_for_testing
+
+    Mmtrix::Agent.instance.transaction_sampler.reset!
+
+    Mmtrix::Agent.shutdown
+
+    # If we didn't start up right, our Control might not have reset on shutdown
+    Mmtrix::Control.reset
+  end
+
+  def run_agent(options={}, &block)
+    setup_agent(options)
+    yield if block_given?
+    teardown_agent
+  end
+
+  def trigger_agent_reconnect(opts={})
+    # Clean-up if others don't (or we're first test after auto-loading of agent)
+    if Mmtrix::Agent.instance.started?
+      Mmtrix::Agent.shutdown
+      Mmtrix::Agent.logger.warn("TESTING: Agent wasn't shut down before test")
+    end
+
+    # This will force a reconnect when we start again
+    Mmtrix::Agent.instance.instance_variable_set(:@connect_state, :pending)
+
+    # Almost always want a test to force a new connect when setting up
+    defaults = { :sync_startup => true, :force_reconnect => true }
+
+    Mmtrix::Agent.manual_start(defaults.merge(opts))
+  end
+
+  #
+  # Collector interactions
+  #
+  # These are here to ease interactions with the fake collector, and allow
+  # classes that don't need them to avoid it by an environment variable.
+  # This helps so the runner process can decide before spawning the child
+  # whether we want the collector running or not.
+
+  def ensure_fake_collector
+    require 'fake_collector'
+    $collector ||= Mmtrix::FakeCollector.new
+    $collector.reset
+  end
+
+  def start_fake_collector
+    $collector.restart if $collector.needs_restart?
+    agent.service.collector.port = $collector.port if agent
+  end
+
+  def omit_collector?
+    ENV["MMTRIX_OMIT_FAKE_COLLECTOR"] == "true"
+  end
+
+  def run_harvest
+    Mmtrix::Agent.instance.send(:transmit_data)
+    Mmtrix::Agent.instance.send(:transmit_event_data)
+  end
+
+  def single_transaction_trace_posted
+    posts = $collector.calls_for("transaction_sample_data")
+    assert_equal 1, posts.length, "Unexpected post count"
+
+    transactions = posts.first.samples
+    assert_equal 1, transactions.length, "Unexpected trace count"
+
+    transactions.first
+  end
+
+  def single_error_posted
+    assert_equal 1, $collector.calls_for("error_data").length
+    assert_equal 1, $collector.calls_for("error_data").first.errors.length
+
+    $collector.calls_for("error_data").first.errors.first
+  end
+
+  def single_event_posted
+    assert_equal 1, $collector.calls_for("analytic_event_data").length
+    assert_equal 1, $collector.calls_for("analytic_event_data").first.events.length
+
+    $collector.calls_for("analytic_event_data").first.events.first
+  end
+
+  def single_connect_posted
+    assert_equal 1, $collector.calls_for(:connect).size
+    $collector.calls_for(:connect).first
+  end
+
+  def capture_js_data
+    state = Mmtrix::Agent::TransactionState.tl_get
+    events = stub(:subscribe => nil)
+    @instrumentor = Mmtrix::Agent::JavascriptInstrumentor.new(events)
+    @js_data = @instrumentor.data_for_js_agent(state)
+
+    raw_attributes = @js_data["atts"]
+
+    if raw_attributes
+      attributes = Mmtrix::JSONWrapper.load @instrumentor.obfuscator.deobfuscate(raw_attributes)
+      @js_custom_attributes = attributes['u']
+      @js_agent_attributes = attributes['a']
+    end
+  end
+
+  def assert_transaction_trace_has_agent_attribute(attribute, expected)
+    actual = single_transaction_trace_posted.agent_attributes[attribute]
+    assert_equal expected, actual
+  end
+
+  def assert_event_has_agent_attribute(attribute, expected)
+    assert_equal expected, single_event_posted.last[attribute]
+  end
+
+  def assert_error_has_agent_attribute(attribute, expected)
+    assert_equal expected, single_error_posted.params["agentAttributes"][attribute]
+  end
+
+  def assert_transaction_tracer_has_custom_attributes(attribute, expected)
+    actual = single_transaction_trace_posted.custom_attributes[attribute]
+    assert_equal expected, actual
+  end
+
+  def assert_transaction_event_has_custom_attributes(attribute, expected)
+    assert_equal expected, single_event_posted[1][attribute]
+  end
+
+  def assert_error_collector_has_custom_attributes(attribute, expected)
+    assert_equal expected, single_error_posted.params["userAttributes"][attribute]
+  end
+
+  def assert_browser_monitoring_has_custom_attributes(attribute, expected)
+    assert_equal expected, @js_custom_attributes[attribute]
+  end
+
+  def assert_browser_monitoring_has_agent_attribute(attribute, expected)
+    assert_equal expected, @js_agent_attributes[attribute]
+  end
+
+  def refute_transaction_tracer_has_custom_attributes(attribute)
+    refute_includes single_transaction_trace_posted.custom_attributes, attribute
+  end
+
+  def refute_transaction_event_has_custom_attributes(attribute)
+    refute_includes single_event_posted[1], attribute
+  end
+
+  def refute_error_collector_has_custom_attributes(attribute)
+    refute_includes single_error_posted.params["userAttributes"], attribute
+  end
+
+  def refute_browser_monitoring_has_custom_attributes(_)
+    assert_nil @js_custom_attributes
+  end
+
+  def refute_transaction_trace_has_agent_attribute(attribute)
+    refute_includes single_transaction_trace_posted.agent_attributes, attribute
+  end
+
+  def refute_event_has_agent_attribute(attribute)
+    refute_includes single_event_posted.last, attribute
+  end
+
+  def refute_error_has_agent_attribute(attribute)
+    refute_includes single_error_posted.params["agentAttributes"], attribute
+  end
+
+  def refute_browser_monitoring_has_any_attributes
+    refute_includes @js_data, "atts"
+  end
+
+  def refute_browser_monitoring_has_agent_attribute(_)
+    assert_nil @js_agent_attributes
+  end
+
+  def refute_event_has_attribute(key)
+    evt = single_event_posted
+    refute_includes evt[0], key, "Found unexpected attribute #{key} in txn event intrinsics"
+    refute_includes evt[1], key, "Found unexpected attribute #{key} in txn event custom attributes"
+    refute_includes evt[2], key, "Found unexpected attribute #{key} in txn event agent attributes"
+  end
+
+  def attributes_for_single_error_posted(key)
+    run_harvest
+    single_error_posted.params[key]
+  end
+
+  def user_attributes_for_single_error_posted
+    attributes_for_single_error_posted("userAttributes")
+  end
+
+  def agent_attributes_for_single_error_posted
+    attributes_for_single_error_posted("agentAttributes")
+  end
+
+  def agent_attributes_for_single_event_posted
+    run_harvest
+    single_event_posted[2]
+  end
+
+  def agent_attributes_for_single_event_posted_without_ignored_attributes
+    ignored_keys = ["httpResponseCode", "request.headers.referer",
+      "request.parameters.controller", "request.parameters.action"]
+    attrs = agent_attributes_for_single_event_posted
+    ignored_keys.each { |k| attrs.delete(k) }
+    attrs
+  end
+
+  extend self
+end