mmtrix_rpm 1.0.0.1

data/test/mmtrix/agent/agent_test_controller.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+# Defining a test controller class with a superclass, used to
+# verify correct attribute inheritence
+class Mmtrix::Agent::SuperclassController <  ActionController::Base
+  def base_action
+    render :text => 'none'
+  end
+end
+# This is a controller class used in testing controller instrumentation
+class Mmtrix::Agent::AgentTestController < Mmtrix::Agent::SuperclassController
+  include Mmtrix::TestHelpers::Exceptions
+  # filter_parameter_logging :social_security_number
+
+  @@headers_to_add = nil
+
+  def index
+    sleep params['wait'].to_f if params['wait']
+    render :text => params.inspect
+  end
+  def _filter_parameters(params)
+    filter_parameters params
+  end
+  def action_inline
+    render(:inline => "<%= 'foo' %>fah")
+  end
+
+  def action_to_render
+    render :text => params.inspect
+  end
+  def action_to_ignore
+    render :text => 'unmeasured'
+  end
+  def action_to_ignore_apdex
+    render :text => 'unmeasured'
+  end
+  before_filter :oops, :only => :action_with_before_filter_error
+  def action_with_before_filter_error
+    render :text => 'nothing'
+  end
+  def oops
+    raise "error in before filter"
+  end
+
+  def rescue_action_locally(exception)
+    if exception.is_a? TestException
+      raise "error in the handler"
+    end
+  end
+  def action_with_error
+    raise "error in action"
+  end
+  def entry_action
+    perform_action_with_mmtrix_trace(:name => 'internal_action') do
+      internal_action
+    end
+  end
+
+  def self.set_some_headers(hash_of_headers)
+    if ::Rails::VERSION::MAJOR.to_i == 4
+      Mmtrix::Agent.instance.events.notify(:before_call, hash_of_headers)
+    else
+      @@headers_to_add ||= {}
+      @@headers_to_add.merge!(hash_of_headers)
+    end
+  end
+
+  def self.clear_headers
+    @@headers_to_add = nil
+  end
+
+  def mmtrix_request_headers(_)
+    @@headers_to_add ||= {}
+  end
+
+  private
+  def internal_action
+    perform_action_with_mmtrix_trace(:name => 'internal_traced_action', :force => true) do
+      render :text => 'internal action'
+    end
+  end
+end

data/test/mmtrix/agent/apdex_from_server_test.rb

@@ -0,0 +1,13 @@
+# 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::Agent::ApdexFromServerTest < Minitest::Test
+
+  def test_true
+    # we need tests in this file - TBD
+    assert true
+  end
+end

data/test/mmtrix/agent/attribute_filter_test.rb

@@ -0,0 +1,218 @@
+# 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/agent/attribute_filter'
+require 'pp'
+
+module Mmtrix::Agent
+  class AttributeFilterTest < Minitest::Test
+    test_cases = load_cross_agent_test("attribute_configuration")
+    test_cases.each do |test_case|
+      define_method("test_#{test_case['testname'].gsub(/\W/, "_")}") do
+        with_config(test_case['config']) do
+          filter = AttributeFilter.new(Mmtrix::Agent.config)
+
+          attribute_name            = test_case['input_key']
+          desired_destination_names = test_case['input_default_destinations']
+
+          desired_destinations  = to_bitfield(desired_destination_names)
+          actual_destinations   = filter.apply(attribute_name, desired_destinations)
+          expected_destinations = to_bitfield(test_case['expected_destinations'])
+
+          assert_equal(to_names(expected_destinations), to_names(actual_destinations),
+                       PP.pp(test_case, "") + PP.pp(filter.rules, ""))
+        end
+      end
+    end
+
+    def test_allows?
+      with_all_enabled do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        default_destination = AttributeFilter::DST_ALL
+
+        assert filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_EVENTS)
+        assert filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_TRACER)
+        assert filter.allows?(default_destination, AttributeFilter::DST_ERROR_COLLECTOR)
+        assert filter.allows?(default_destination, AttributeFilter::DST_BROWSER_MONITORING)
+      end
+    end
+
+    def test_allows_with_restricted_default_destination
+      with_all_enabled do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        default_destination = AttributeFilter::DST_ERROR_COLLECTOR
+
+        assert filter.allows?(default_destination, AttributeFilter::DST_ERROR_COLLECTOR)
+
+        refute filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_EVENTS)
+        refute filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_TRACER)
+        refute filter.allows?(default_destination, AttributeFilter::DST_BROWSER_MONITORING)
+      end
+    end
+
+
+    def test_allows_with_multiple_default_destinations
+      with_all_enabled do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        default_destination = AttributeFilter::DST_ERROR_COLLECTOR|AttributeFilter::DST_TRANSACTION_TRACER
+
+        assert filter.allows?(default_destination, AttributeFilter::DST_ERROR_COLLECTOR)
+        assert filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_TRACER)
+
+        refute filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_EVENTS)
+        refute filter.allows?(default_destination, AttributeFilter::DST_BROWSER_MONITORING)
+      end
+    end
+
+    def test_capture_params_false_adds_exclude_rule_for_request_parameters
+      with_config(:capture_params => false) do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        result = filter.apply 'request.parameters.muggle', AttributeFilter::DST_NONE
+
+        assert_destinations [], result
+      end
+    end
+
+    def test_capture_params_true_allows_request_params_for_traces_and_errors
+      with_config(:capture_params => true) do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        result = filter.apply 'request.parameters.muggle', AttributeFilter::DST_NONE
+
+        assert_destinations ['transaction_tracer', 'error_collector'], result
+      end
+    end
+
+    def test_resque_capture_params_false_adds_exclude_rule_for_request_parameters
+      with_config(:'resque.capture_params' => false) do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        result = filter.apply 'job.resque.args.*', AttributeFilter::DST_NONE
+
+        assert_destinations [], result
+      end
+    end
+
+    def test_resque_capture_params_true_allows_request_params_for_traces_and_errors
+      with_config(:'resque.capture_params' => true) do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        result = filter.apply 'job.resque.args.*', AttributeFilter::DST_NONE
+
+        assert_destinations ['transaction_tracer', 'error_collector'], result
+      end
+    end
+
+    def test_sidekiq_capture_params_false_adds_exclude_rule_for_request_parameters
+      with_config(:'sidekiq.capture_params' => false) do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        result = filter.apply 'job.sidekiq.args.*', AttributeFilter::DST_NONE
+
+        assert_destinations [], result
+      end
+    end
+
+    def test_sidekiq_capture_params_true_allows_request_params_for_traces_and_errors
+      with_config(:'sidekiq.capture_params' => true) do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        result = filter.apply 'job.sidekiq.args.*', AttributeFilter::DST_NONE
+
+        assert_destinations ['transaction_tracer', 'error_collector'], result
+      end
+    end
+
+    def test_might_allow_prefix_default_case
+      filter = AttributeFilter.new(Mmtrix::Agent.config)
+      refute filter.might_allow_prefix?(:'request.parameters')
+    end
+
+    def test_might_allow_prefix_blanket_include
+      with_config(:'attributes.include' => '*') do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        assert filter.might_allow_prefix?(:'request.parameters')
+      end
+    end
+
+    def test_might_allow_prefix_general_include
+      with_config(:'attributes.include' => 'request.*') do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        assert filter.might_allow_prefix?(:'request.parameters')
+      end
+    end
+
+    def test_might_allow_prefix_prefix_include
+      with_config(:'attributes.include' => 'request.parameters.*') do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        assert filter.might_allow_prefix?(:'request.parameters')
+      end
+    end
+
+    def test_might_allow_prefix_prefix_include_tt_only
+      with_config(:'transaction_tracer.attributes.include' => 'request.parameters.*') do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        assert filter.might_allow_prefix?(:'request.parameters')
+      end
+    end
+
+    def test_might_allow_prefix_non_matching_include
+      with_config(:'transaction_tracer.attributes.include' => 'otherthing') do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        refute filter.might_allow_prefix?(:'request.parameters')
+      end
+    end
+
+    def test_might_allow_prefix_more_specific_rule
+      with_config(:'attributes.include' => 'request.parameters.lolz') do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        assert filter.might_allow_prefix?(:'request.parameters')
+      end
+    end
+
+    def test_might_allow_prefix_more_specific_rule_with_wildcard
+      with_config(:'attributes.include' => 'request.parameters.lolz.*') do
+        filter = AttributeFilter.new(Mmtrix::Agent.config)
+        assert filter.might_allow_prefix?(:'request.parameters')
+      end
+    end
+
+    def assert_destinations(expected, result)
+      assert_equal to_bitfield(expected), result, "Expected #{expected}, got #{to_names(result)}"
+    end
+
+    def to_names(bitfield)
+      names = []
+
+      names << 'transaction_events' if (bitfield & AttributeFilter::DST_TRANSACTION_EVENTS) != 0
+      names << 'transaction_tracer' if (bitfield & AttributeFilter::DST_TRANSACTION_TRACER) != 0
+      names << 'error_collector'    if (bitfield & AttributeFilter::DST_ERROR_COLLECTOR)    != 0
+      names << 'browser_monitoring' if (bitfield & AttributeFilter::DST_BROWSER_MONITORING) != 0
+
+      names
+    end
+
+    def to_bitfield(destination_names)
+      bitfield = AttributeFilter::DST_NONE
+
+      destination_names.each do |name|
+        case name
+        when 'transaction_events' then bitfield |= AttributeFilter::DST_TRANSACTION_EVENTS
+        when 'transaction_tracer' then bitfield |= AttributeFilter::DST_TRANSACTION_TRACER
+        when 'error_collector'    then bitfield |= AttributeFilter::DST_ERROR_COLLECTOR
+        when 'browser_monitoring' then bitfield |= AttributeFilter::DST_BROWSER_MONITORING
+        end
+      end
+
+      bitfield
+    end
+
+    def with_all_enabled
+      with_config(
+        :'transaction_tracer.attributes.enabled' => true,
+        :'transaction_events.attributes.enabled' => true,
+        :'error_collector.attributes.enabled' => true,
+        :'browser_monitoring.attributes.enabled' => true) do
+        yield
+      end
+    end
+  end
+end

data/test/mmtrix/agent/attribute_processing_test.rb

@@ -0,0 +1,165 @@
+# 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/agent/attribute_processing'
+
+class AttributeProcessingTest < Minitest::Test
+  def test_flatten_and_coerce_handles_nested_hashes
+    params = {"user" =>
+      {"addresses" =>
+        [
+          {"street" => "123 Street", "city" => "City", "state" => "ST", "zip" => "12345"},
+          {"street" => "123 Blvd", "city" => "City2", "state" => "ST2", "zip" => "54321"}
+        ]
+      }
+    }
+
+    expected = {
+      "request.parameters.user.addresses.0.street" => "123 Street",
+      "request.parameters.user.addresses.0.city"   => "City",
+      "request.parameters.user.addresses.0.state"  => "ST",
+      "request.parameters.user.addresses.0.zip"    => "12345",
+      "request.parameters.user.addresses.1.street" => "123 Blvd",
+      "request.parameters.user.addresses.1.city"   => "City2",
+      "request.parameters.user.addresses.1.state"  => "ST2",
+      "request.parameters.user.addresses.1.zip"    => "54321"
+    }
+
+    actual = Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(params, 'request.parameters')
+
+    assert_equal(expected, actual)
+  end
+
+  def test_flatten_and_coerce_coerces_values
+    params = {
+      "v1" => Class.new,
+      "v2" => :symbol,
+      "v3" => 1.01
+    }
+
+    expected = {
+      "request.parameters.v1" => "#<Class>",
+      "request.parameters.v2" => "symbol",
+      "request.parameters.v3" => 1.01
+    }
+
+    actual = Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(params, 'request.parameters')
+
+    assert_equal(expected, actual)
+  end
+
+  def test_prefix_optional_for_flatten_and_coerce
+    params = {:foo => {:bar => ["v1", "v2"]}}
+
+    expected = {
+      "foo.bar.0" => "v1",
+      "foo.bar.1" => "v2"
+    }
+
+    actual = Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(params)
+
+    assert_equal(expected, actual)
+  end
+
+  def test_prefix_optional_for_flatten_and_coerce_with_initial_array_argument
+    params = [:foo => {:bar => ["v1", "v2"]}]
+
+    expected = {
+      "0.foo.bar.0" => "v1",
+      "0.foo.bar.1" => "v2"
+    }
+
+    actual = Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(params)
+
+    assert_equal(expected, actual)
+  end
+
+  def test_flatten_and_coerce_replaces_empty_hash_with_string_representation
+    params = {:foo => {:bar => {}}}
+
+    expected = { "foo.bar" => "{}" }
+
+    actual = Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(params)
+
+    assert_equal(expected, actual)
+  end
+
+  def test_flatten_and_coerce_replaces_empty_array_with_string_representation
+    params = {:foo => {:bar => []}}
+
+    expected = { "foo.bar" => "[]" }
+
+    actual = Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(params)
+
+    assert_equal(expected, actual)
+  end
+
+  def test_flatten_and_coerce_coerce_handles_values_mixed_and_complex_types_properly
+    assert_equal(
+      {
+        'foo'    => 1.0,
+        'bar'    => 2,
+        'bang'   => 'woot',
+        'ok'     => 'dokey',
+        'yes'    => '[]',
+        'yup'    => '{}',
+        'yayuh'  => '#<Rational>',
+        'truthy' => true,
+        'falsy'  => false
+      },
+      Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(
+        {
+          'foo'    => 1.0,
+          'bar'    => 2,
+          'bang'   => 'woot',
+          'ok'     => :dokey,
+          'yes'    => [],
+          'yup'  => {},
+          'yayuh'   => Rational(1),
+          'truthy' => true,
+          'falsy'  => false
+        }
+      )
+    )
+  end
+
+  def test_flatten_and_coerce_turns_nan_or_infinity_into_null_and_then_dropped
+    assert_equal(
+      {
+      },
+      Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(
+        {
+          # Ruby 1.8.7 doesn't have Float::NAN, INFINITY so we have to hack it
+          'nan'  => 0.0  / 0.0,
+          'inf'  => 1.0  / 0.0,
+          'ninf' => -1.0 / 0.0
+        }
+      )
+    )
+  end
+
+  def test_flatten_and_coerce_logs_warning_with_unexpected_arguments
+    expects_logging(:warn, all_of(includes("Unexpected object"), includes("flatten_and_coerce")))
+    Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(Object.new)
+  end
+
+  def test_flatten_and_coerce_calls_a_block_key_and_value_when_provided
+    params = {:foo => {:bar => ["qux", "quux"]}}
+    yielded = {}
+
+    Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(params) { |k, v| yielded[k] = v}
+
+    expected = {"foo.bar.0" => "qux", "foo.bar.1" => "quux"}
+    assert_equal expected, yielded
+  end
+
+  def test_flatten_and_coerce_leaves_nils_alone
+    params   = { :referer => nil }
+    expected = { }
+
+    result = Mmtrix::Agent::AttributeProcessing.flatten_and_coerce(params)
+    assert_equal expected, result
+  end
+end

data/test/mmtrix/agent/audit_logger_test.rb

@@ -0,0 +1,213 @@
+# 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/agent/audit_logger'
+require 'mmtrix/agent/null_logger'
+
+class AuditLoggerTest < Minitest::Test
+  def setup
+    Mmtrix::Agent.config.add_config_for_testing(:'audit_log.enabled' => true)
+
+    @uri = "http://really.notreal"
+    @marshaller = Mmtrix::Agent::MmtrixService::Marshaller.new
+    @dummy_data = {
+      'foo' => [1, 2, 3],
+      'bar' => {
+        'baz' => 'qux',
+        'jingle' => 'bells'
+      }
+    }
+  end
+
+  def teardown
+    Mmtrix::Agent.config.reset_to_defaults
+  end
+
+  def setup_fake_logger
+    @fakelog = StringIO.new
+    @logger = Mmtrix::Agent::AuditLogger.new
+    @logger.stubs(:ensure_log_path).returns(@fakelog)
+  end
+
+  def setup_fake_logger_with_failure(error)
+    setup_fake_logger
+    @logger.stubs(:enabled?).raises(error)
+  end
+
+  def assert_log_contains_string(str)
+    log_body = read_log_body
+    assert(log_body.include?(str), "Expected log to contain string '#{str}'\nLog body was: #{log_body}")
+  end
+
+  def read_log_body
+    @fakelog.rewind
+    @fakelog.read
+  end
+
+  def test_never_setup_if_disabled
+    with_config(:'audit_log.enabled' => false) do
+      logger = Mmtrix::Agent::AuditLogger.new
+      logger.log_request(@uri, "hi there", @marshaller)
+      assert(!logger.setup?, "Expected logger to not have been setup")
+    end
+  end
+
+  def test_never_prepare_if_disabled
+    with_config(:'audit_log.enabled' => false) do
+      logger = Mmtrix::Agent::AuditLogger.new
+      marshaller = Mmtrix::Agent::MmtrixService::Marshaller.new
+      marshaller.expects(:prepare).never
+      logger.log_request(@uri, "hi there", @marshaller)
+    end
+  end
+
+  def test_log_formatter
+    Socket.stubs(:gethostname).returns('dummyhost')
+    formatter = Mmtrix::Agent::AuditLogger.new.create_log_formatter
+    time = '2012-01-01 00:00:00'
+    msg = 'hello'
+    result = formatter.call(Logger::INFO, time, 'bleh', msg)
+    expected = "[2012-01-01 00:00:00 dummyhost (#{$$})] : hello\n"
+    assert_equal(expected, result)
+  end
+
+  def test_log_formatter_to_stdout
+    with_config(:'audit_log.path' => "STDOUT") do
+      Socket.stubs(:gethostname).returns('dummyhost')
+      formatter = Mmtrix::Agent::AuditLogger.new.create_log_formatter
+      time = '2012-01-01 00:00:00'
+      msg = 'hello'
+      result = formatter.call(Logger::INFO, time, 'bleh', msg)
+      expected = "** [Mmtrix][2012-01-01 00:00:00 dummyhost (#{$$})] : hello\n"
+      assert_equal(expected, result)
+    end
+  end
+
+  def test_ensure_path_returns_nil_with_bogus_path
+    with_config(:'audit_log.path' => '/really/really/not/a/path') do
+      FileUtils.stubs(:mkdir_p).raises(SystemCallError, "i'd rather not")
+      logger = Mmtrix::Agent::AuditLogger.new
+      assert_nil(logger.ensure_log_path)
+    end
+  end
+
+  def test_setup_logger_creates_null_logger_when_ensure_path_fails
+    null_logger = Mmtrix::Agent::NullLogger.new
+    Mmtrix::Agent::NullLogger.expects(:new).returns(null_logger)
+    logger = Mmtrix::Agent::AuditLogger.new
+    logger.stubs(:ensure_log_path).returns(nil)
+
+    logger.setup_logger
+    logger.log_request(@uri, 'whatever', @marshaller)
+  end
+
+  def test_log_request_captures_system_call_errors
+    logger = Mmtrix::Agent::AuditLogger.new
+    dummy_sink = StringIO.new
+    dummy_sink.stubs(:write).raises(SystemCallError, "nope")
+    logger.stubs(:ensure_log_path).returns(dummy_sink)
+
+    # In 1.9.2 and later, Logger::LogDevice#write captures any errors during
+    # writing and spits them out with Kernel#warn.
+    # This just silences that output to keep the test output uncluttered.
+    Logger::LogDevice.any_instance.stubs(:warn)
+
+    logger.log_request(@uri, 'whatever', @marshaller)
+  end
+
+  def test_prepares_data_with_identity_encoder
+    setup_fake_logger
+    data = { 'foo' => 'bar' }
+    identity_encoder = Mmtrix::Agent::MmtrixService::Encoders::Identity
+    @marshaller.expects(:prepare).with(data, { :encoder => identity_encoder })
+    @logger.log_request(@uri, data, @marshaller)
+  end
+
+  def test_logs_inspect_with_pruby_marshaller
+    setup_fake_logger
+    pruby_marshaller = Mmtrix::Agent::MmtrixService::PrubyMarshaller.new
+    @logger.log_request(@uri, @dummy_data, pruby_marshaller)
+    assert_log_contains_string(@dummy_data.inspect)
+  end
+
+  def test_logs_json_with_json_marshaller
+    marshaller_cls = Mmtrix::Agent::MmtrixService::JsonMarshaller
+    if marshaller_cls.is_supported?
+      setup_fake_logger
+      json_marshaller = marshaller_cls.new
+      @logger.log_request(@uri, @dummy_data, json_marshaller)
+      assert_audit_log_contains_object(read_log_body, @dummy_data, :json)
+    end
+  end
+
+  def test_allows_through_endpoints
+    fake_metrics = { 'metric' => 'yup' }
+    with_config(:'audit_log.endpoints' => ['metric_data']) do
+      setup_fake_logger
+      @logger.log_request('host/metric_data', fake_metrics, @marshaller)
+      assert_log_contains_string(fake_metrics.inspect)
+    end
+  end
+
+  def test_filters_endpoints
+    fake_txn = { 'txn' => 'nope' }
+    with_config(:'audit_log.endpoints' => ['metric_data']) do
+      setup_fake_logger
+      @logger.log_request('host/transaction_sample_data', fake_txn, @marshaller)
+      assert_empty read_log_body
+    end
+  end
+
+  def test_should_cache_hostname
+    Socket.expects(:gethostname).once.returns('cachey-mccaherson')
+    setup_fake_logger
+    3.times do
+      @logger.log_request(@uri, @dummy_data, @marshaller)
+    end
+    assert_log_contains_string('cachey-mccaherson')
+  end
+
+  TRAPPABLE_ERRORS = [
+    StandardError.new,
+    SystemStackError.new,
+    SystemCallError.new("Syscalls FTW")
+  ]
+
+  TRAPPABLE_ERRORS.each do |error|
+    define_method("test_traps_#{error.class}") do
+      setup_fake_logger_with_failure(error)
+      @logger.log_request(@uri, @dummy_data, @marshaller)
+      assert_empty read_log_body
+    end
+  end
+
+  def test_allows_other_exceptions_through
+    setup_fake_logger_with_failure(Exception.new)
+    assert_raises(Exception) do
+      @logger.log_request(@uri, @dummy_data, @marshaller)
+    end
+  end
+
+  def test_writes_to_stdout
+    with_config(:'audit_log.path' => "STDOUT") do
+      output = capturing_stdout do
+        @logger = Mmtrix::Agent::AuditLogger.new
+        @logger.log_request(@uri, @dummy_data, @marshaller)
+      end
+
+      assert_includes output, @dummy_data.inspect
+    end
+  end
+
+  def capturing_stdout
+    orig = $stdout.dup
+    output = ""
+    $stdout = StringIO.new(output)
+    yield
+    output
+  ensure
+    $stdout = orig
+  end
+end