mmtrix_rpm 1.0.0.1

data/test/mmtrix/noticed_error_test.rb

@@ -0,0 +1,197 @@
+# 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/transaction/attributes'
+
+class Mmtrix::Agent::NoticedErrorTest < Minitest::Test
+  include Mmtrix::TestHelpers::Exceptions
+
+  def setup
+    @path = 'foo/bar/baz'
+
+    freeze_time
+    @time = Time.now
+
+    @attributes = Mmtrix::Agent::Transaction::Attributes.new(Mmtrix::Agent.instance.attribute_filter)
+    @attributes_from_notice_error = { :user => 'params' }
+  end
+
+  def test_to_collector_array
+    e = TestError.new('test exception')
+
+    error = create_error(e)
+    error.request_uri = "http://com.google"
+    error.attributes_from_notice_error = @attributes_from_notice_error
+
+    expected = [
+      (@time.to_f * 1000).round,
+      @path,
+      'test exception',
+      'Mmtrix::TestHelpers::Exceptions::TestError',
+      {
+        :request_uri      => 'http://com.google',
+        'userAttributes'  => { 'user' => 'params' },
+        'agentAttributes' => {},
+        'intrinsics'      => {}
+      }
+    ]
+    assert_equal expected, error.to_collector_array
+  end
+
+  def test_to_collector_array_merges_custom_attributes_and_params
+    e = TestError.new('test exception')
+    @attributes.merge_custom_attributes(:custom => "attribute")
+
+    error = create_error(e)
+    error.attributes_from_notice_error = @attributes_from_notice_error
+
+    actual = extract_attributes(error)
+    expected = {
+      'userAttributes' => {
+        'user'   => 'params',
+        'custom' => 'attribute'
+      },
+      'agentAttributes' => {},
+      'intrinsics'      => {}
+    }
+
+    assert_equal expected, actual
+  end
+
+  def test_to_collector_array_includes_agent_attributes
+    e = TestError.new('test exception')
+    @attributes.add_agent_attribute(:agent, "attribute", Mmtrix::Agent::AttributeFilter::DST_ALL)
+    error = create_error(e)
+
+    actual = extract_attributes(error)
+    assert_equal({:agent => "attribute"}, actual["agentAttributes"])
+  end
+
+  def test_to_collector_array_includes_intrinsic_attributes
+    e = TestError.new('test exception')
+    @attributes.add_intrinsic_attribute(:intrinsic, "attribute")
+    error = create_error(e)
+
+    actual = extract_attributes(error)
+    assert_equal({:intrinsic => "attribute"}, actual["intrinsics"])
+  end
+
+  def test_to_collector_array_happy_without_attribute_collections
+    error = Mmtrix::NoticedError.new(@path, "BOOM")
+
+    expected = [
+      (@time.to_f * 1000).round,
+      @path,
+      "BOOM",
+      "Error",
+      {
+        'userAttributes'  => {},
+        'agentAttributes' => {},
+        'intrinsics'      => {}
+      }
+    ]
+    assert_equal expected, error.to_collector_array
+  end
+
+  def test_to_collector_array_with_bad_values
+    error = Mmtrix::NoticedError.new(@path, nil, Rational(10, 1))
+    expected = [
+      10_000.0,
+      @path,
+      "<no message>",
+      "Error",
+      {
+        'userAttributes'  => {},
+        'agentAttributes' => {},
+        'intrinsics'      => {}
+      }
+    ]
+    assert_equal expected, error.to_collector_array
+  end
+
+  def test_handles_non_string_exception_messages
+    e = Exception.new({ :non => :string })
+    error = Mmtrix::NoticedError.new(@path, e, @time)
+    assert_equal(String, error.message.class)
+  end
+
+  def test_strips_message_from_exceptions_in_high_security_mode
+    with_config(:high_security => true) do
+      e = TestError.new('test exception')
+      error = Mmtrix::NoticedError.new(@path, e, @time)
+
+      assert_equal Mmtrix::NoticedError::STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE, error.message
+    end
+  end
+
+  def test_permits_messages_from_whitelisted_exceptions_in_high_security_mode
+    with_config(:'strip_exception_messages.whitelist' => 'Mmtrix::TestHelpers::Exceptions::TestError') do
+      e = TestError.new('whitelisted test exception')
+      error = Mmtrix::NoticedError.new(@path, e, @time)
+
+      assert_equal 'whitelisted test exception', error.message
+    end
+  end
+
+  def test_whitelisted_returns_nil_with_an_empty_whitelist
+    with_config(:'strip_exception_messages.whitelist' => '') do
+      assert_falsy Mmtrix::NoticedError.passes_message_whitelist(TestError)
+    end
+  end
+
+  def test_whitelisted_returns_nil_when_error_is_not_in_whitelist
+    with_config(:'strip_exception_messages.whitelist' => 'YourErrorIsInAnotherCastle') do
+      assert_falsy Mmtrix::NoticedError.passes_message_whitelist(TestError)
+    end
+  end
+
+  def test_whitelisted_is_true_when_error_is_in_whitelist
+    with_config(:'strip_exception_messages.whitelist' => 'OtherException,Mmtrix::TestHelpers::Exceptions::TestError') do
+      assert_truthy Mmtrix::NoticedError.passes_message_whitelist(TestError)
+    end
+  end
+
+  def test_whitelisted_ignores_nonexistent_exception_types_in_whitelist
+    with_config(:'strip_exception_messages.whitelist' => 'NonExistent::Exception,Mmtrix::TestHelpers::Exceptions::TestError') do
+      assert_truthy Mmtrix::NoticedError.passes_message_whitelist(TestError)
+    end
+  end
+
+  def test_whitelisted_is_true_when_an_exceptions_ancestor_is_whitelisted
+    with_config(:'strip_exception_messages.whitelist' => 'Mmtrix::TestHelpers::Exceptions::ParentException') do
+      assert_truthy Mmtrix::NoticedError.passes_message_whitelist(ChildException)
+    end
+  end
+
+  def test_handles_exception_with_nil_original_exception
+    e = Exception.new('Buffy FOREVER')
+    e.stubs(:original_exception).returns(nil)
+    error = Mmtrix::NoticedError.new(@path, e, @time)
+    assert_equal(error.message.to_s, 'Buffy FOREVER')
+  end
+
+  def test_intrinsics_always_get_sent
+    with_config(:'error_collector.attributes.enabled' => false) do
+      attributes = Mmtrix::Agent::Transaction::Attributes.new(Mmtrix::Agent.instance.attribute_filter)
+      attributes.add_intrinsic_attribute(:intrinsic, "attribute")
+
+      error = Mmtrix::NoticedError.new(@path, Exception.new("O_o"))
+      error.attributes = attributes
+
+      serialized_attributes = extract_attributes(error)
+      assert_equal({ :intrinsic => "attribute" }, serialized_attributes["intrinsics"])
+    end
+  end
+
+  def create_error(exception = StandardError.new)
+    noticed_error = Mmtrix::NoticedError.new(@path, exception, @time)
+    noticed_error.attributes = @attributes
+    noticed_error
+  end
+
+  def extract_attributes(error)
+    error.to_collector_array[4]
+  end
+end

data/test/mmtrix/rack/agent_hooks_test.rb

@@ -0,0 +1,44 @@
+# 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/rack/agent_hooks'
+
+class AgentHooksTest < Minitest::Test
+
+  def setup
+    @app = stub_everything
+    @hooks = Mmtrix::Rack::AgentHooks.new(@app)
+    @env = {:env => "env"}
+  end
+
+  def test_before_call
+    Mmtrix::Agent.instance.events.expects(:notify).with(:start_transaction)
+    Mmtrix::Agent.instance.events.expects(:notify).with(:before_call, @env)
+    Mmtrix::Agent.instance.events.stubs(:notify).with(:after_call, anything, anything)
+    Mmtrix::Agent.instance.events.expects(:notify).with(:transaction_finished, anything)
+
+    @hooks.call(@env)
+  end
+
+  def test_after_call
+    result = [stub, stub, stub]
+    @app.stubs(:call).returns(result)
+
+    Mmtrix::Agent.instance.events.expects(:notify).with(:start_transaction)
+    Mmtrix::Agent.instance.events.stubs(:notify).with(:before_call, anything)
+    Mmtrix::Agent.instance.events.expects(:notify).with(:after_call, @env, result)
+    Mmtrix::Agent.instance.events.expects(:notify).with(:transaction_finished, anything)
+
+    @hooks.call(@env)
+  end
+
+  def test_nested_agent_hooks_still_fire_only_once
+    nested = Mmtrix::Rack::AgentHooks.new(@hooks)
+
+    Mmtrix::Agent.instance.events.expects(:notify).times(4)
+    nested.call(@env)
+  end
+
+end

data/test/mmtrix/rack/agent_middleware_test.rb

@@ -0,0 +1,32 @@
+# 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/rack/agent_middleware'
+require 'mmtrix/agent/transaction_state'
+
+module Mmtrix
+  module Rack
+    class AgentMiddlewareTest < Minitest::Test
+      class ExampleMiddleware < AgentMiddleware
+        def traced_call(env)
+          @app.call(env)
+        end
+      end
+
+      attr_reader :middleware, :env
+
+      def setup
+        @app = lambda { |env| [200, {}, ['yeah!']]}
+        @middleware = ExampleMiddleware.new(@app)
+        @env = {}
+      end
+
+      def test_with_tracing_creates_a_transaction
+        middleware.call(env)
+        assert_metrics_recorded('Controller/Middleware/Rack/Mmtrix::Rack::AgentMiddlewareTest::ExampleMiddleware/call')
+      end
+    end
+  end
+end

data/test/mmtrix/rack/browser_monitoring_test.rb

@@ -0,0 +1,197 @@
+# 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 'rack/test'
+require 'mmtrix/agent/instrumentation/rack'
+require 'mmtrix/rack/browser_monitoring'
+
+ENV['RACK_ENV'] = 'test'
+
+class BrowserMonitoringTest < Minitest::Test
+  include Rack::Test::Methods
+
+  class TestApp
+    @@doc = nil
+    @@next_response = nil
+
+    def self.doc=(other)
+      @@doc = other
+    end
+
+    def self.next_response=(next_response)
+      @@next_response = next_response
+    end
+
+    def self.next_response
+      @@next_response
+    end
+
+    def call(env)
+      advance_time(0.1)
+      @@doc ||= <<-EOL
+<html>
+  <head>
+    <title>im a title</title>
+    <meta some-crap="1"/>
+    <script>
+      junk
+    </script>
+  </head>
+  <body>im some body text</body>
+</html>
+EOL
+      response = @@next_response || Rack::Response.new(@@doc)
+      @@next_response = nil
+
+      [200, {'Content-Type' => 'text/html'}, response]
+    end
+    include Mmtrix::Agent::Instrumentation::Rack
+  end
+
+  def app
+    Mmtrix::Rack::BrowserMonitoring.new(TestApp.new)
+  end
+
+  def setup
+    super
+    freeze_time
+
+    @config = {
+      :application_id => 5,
+      :beacon => 'beacon',
+      :browser_key => 'some browser key',
+      :'rum.enabled' => true,
+      :license_key => 'a' * 40,
+      :js_agent_loader => 'loader',
+      :disable_harvest_thread => true
+    }
+    Mmtrix::Agent.config.add_config_for_testing(@config)
+  end
+
+  def teardown
+    super
+    TestApp.doc = nil
+    Mmtrix::Agent.config.remove_config(@config)
+    Mmtrix::Agent.agent.transaction_sampler.reset!
+  end
+
+  def test_make_sure_header_is_set
+    in_transaction do
+      assert Mmtrix::Agent.browser_timing_header.size > 0
+    end
+  end
+
+  def test_should_only_instrument_successful_html_requests
+    assert app.should_instrument?({}, 200, {'Content-Type' => 'text/html'}), "Expected to instrument 200 requests."
+    assert !app.should_instrument?({}, 500, {'Content-Type' => 'text/html'}), "Expected not to instrument 500 requests."
+    assert !app.should_instrument?({}, 200, {'Content-Type' => 'text/xhtml'}), "Expected not to instrument requests with content type other than text/html."
+  end
+
+  def test_should_not_instrument_when_content_disposition
+    assert !app.should_instrument?({}, 200, {'Content-Type' => 'text/html', 'Content-Disposition' => 'attachment; filename=test.html'})
+  end
+
+  def test_should_not_instrument_when_already_did
+    assert !app.should_instrument?({Mmtrix::Rack::BrowserMonitoring::ALREADY_INSTRUMENTED_KEY => true}, 200, {'Content-Type' => 'text/html'})
+  end
+
+  def test_should_not_instrument_when_disabled_by_config
+    with_config(:'browser_monitoring.auto_instrument' => false) do
+      refute app.should_instrument?({}, 200, {'Content-Type' => 'text/html'})
+    end
+  end
+
+  def test_insert_header_should_mark_environment
+    get '/'
+    assert last_request.env.key?(Mmtrix::Rack::BrowserMonitoring::ALREADY_INSTRUMENTED_KEY)
+  end
+
+  # RUM header auto-insertion testing
+  # We read *.html files from the rum_loader_insertion_location directory in
+  # cross_agent_tests, strip out the placeholder tokens representing the RUM
+  # header manually, and then re-insert, verifying that it ends up in the right
+  # place.
+
+  source_files = Dir[File.join(cross_agent_tests_dir, 'rum_loader_insertion_location', "*.html")]
+
+  RUM_PLACEHOLDER = "EXPECTED_RUM_LOADER_LOCATION"
+
+  source_files.each do |source_file|
+    source_filename = File.basename(source_file).gsub(".", "_")
+    instrumented_html = File.read(source_file)
+    uninstrumented_html = instrumented_html.gsub(RUM_PLACEHOLDER, '')
+
+    define_method("test_#{source_filename}") do
+      TestApp.doc = uninstrumented_html
+      Mmtrix::Agent.stubs(:browser_timing_header).returns(RUM_PLACEHOLDER)
+
+      get '/'
+
+      assert_equal(instrumented_html, last_response.body)
+    end
+
+    define_method("test_dont_touch_#{source_filename}") do
+      TestApp.doc = uninstrumented_html
+      Mmtrix::Rack::BrowserMonitoring.any_instance.stubs(:should_instrument?).returns(false)
+
+      get '/'
+
+      assert_equal(uninstrumented_html, last_response.body)
+    end
+  end
+
+  def test_should_close_response
+    TestApp.next_response = Rack::Response.new("<html/>")
+    TestApp.next_response.expects(:close)
+
+    get '/'
+
+    assert last_response.ok?
+  end
+
+  def test_with_invalid_us_ascii_encoding
+    response = "<html><body>Jürgen</body></html>"
+    response.force_encoding(Encoding.find("US-ASCII")) if RUBY_VERSION >= '1.9'
+    TestApp.next_response = Rack::Response.new(response)
+
+    get '/'
+
+    assert last_response.ok?
+  end
+
+  def test_should_not_close_if_not_responded_to
+    TestApp.next_response = Rack::Response.new("<html/>")
+    TestApp.next_response.stubs(:respond_to?).with(:close).returns(false)
+    TestApp.next_response.expects(:close).never
+
+    get '/'
+
+    assert last_response.ok?
+  end
+
+  def test_should_not_throw_exception_on_empty_reponse
+    TestApp.doc = ''
+    get '/'
+
+    assert last_response.ok?
+  end
+
+  def test_content_length_set_when_we_modify_source
+    original_headers = {
+      "Content-Length" => 0,
+      "Content-Type"   => "text/html"
+    }
+    headers = headers_from_request(original_headers, "<html><body></body></html>")
+    assert_equal "390", headers["Content-Length"]
+  end
+
+  def headers_from_request(headers, content)
+    app = mock('app', :call => [200, headers, [content]])
+    browser_monitoring = Mmtrix::Rack::BrowserMonitoring.new(app)
+    _, headers, _ = browser_monitoring.call({})
+    headers
+  end
+end

data/test/mmtrix/rack/deferred_instrumentation_test.rb

@@ -0,0 +1,33 @@
+# 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::Rack::DeferredInstrumentationTest < Minitest::Test
+  class TestApp
+    def call(env)
+      [200, {}, ["whatever"]]
+    end
+  end
+
+  def test_to_app_does_not_blow_up_when_rack_instrumentation_required_multiple_times
+    # We want to use two different paths to require the rack instrumentation here
+    # in order to simulate a situation that might arise where a user is
+    # explicitly requiring our rack instrumentation file, and then the agent
+    # automatically requires it as well, via a different path.
+    # On Ruby 1.8.7, this will cause the file to be evaluated multiple times.
+    path1 = "mmtrix/agent/instrumentation/rack"
+    path2 = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'lib', 'mmtrix', 'agent', 'instrumentation', 'rack'))
+    refute_equal(path2, path1)
+
+    require path1
+    require path2
+
+    builder = ::Rack::Builder.new do
+      run(::Mmtrix::Rack::DeferredInstrumentationTest::TestApp.new)
+    end
+
+    builder.to_app
+  end
+end

data/test/mmtrix/rack/developer_mode/segment_summary_test.rb

@@ -0,0 +1,96 @@
+# 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/rack/developer_mode'
+require 'mmtrix/rack/developer_mode/segment_summary'
+
+class SegmentSummaryTest < Minitest::Test
+  def setup
+    @sample = mock('sample')
+    @ss = Mmtrix::Rack::DeveloperMode::SegmentSummary.new('Controller/foo', @sample)
+  end
+
+  # these are mostly stub tests just making sure that the API doesn't
+  # change if anyone ever needs to modify it.
+
+  def test_insert
+    segment = mock('segment')
+    segment.expects(:metric_name).returns('Controller/foo')
+    segment.expects(:duration).returns(0.1)
+    segment.expects(:exclusive_duration).returns(0.1)
+    @ss << segment
+    assert_equal 0.1, @ss.total_time
+    assert_equal 0.1, @ss.exclusive_time
+    assert_equal 1, @ss.call_count
+  end
+
+  def test_insert_error
+    segment = mock('segment')
+    segment.expects(:metric_name).returns('Controller/bar').twice
+    assert_raises(ArgumentError) do
+      @ss << segment
+    end
+  end
+
+  def test_average_time
+    @ss.total_time = 0.1
+    @ss.call_count = 2
+    assert_equal 0.05, @ss.average_time
+  end
+
+  def test_average_exclusive_time
+    @ss.exclusive_time = 0.1
+    @ss.call_count = 2
+    assert_equal 0.05, @ss.average_exclusive_time
+  end
+
+  def test_exclusive_time_percentage_nil
+    @ss.exclusive_time = nil
+    assert_equal 0, @ss.exclusive_time_percentage
+  end
+
+  def test_exclusive_time_percentage
+    @ss.exclusive_time = 0.05
+    @sample.expects(:duration).returns(0.1).times(3)
+    assert_equal 0.5, @ss.exclusive_time_percentage
+  end
+
+  def test_total_time_percentage_nil
+    @ss.total_time = nil
+    assert_equal 0, @ss.total_time_percentage
+  end
+
+  def test_total_time_percentage
+    @ss.total_time = 0.05
+    @sample.expects(:duration).returns(0.1).times(3)
+    assert_equal 0.5, @ss.total_time_percentage
+  end
+
+  def test_nesting_total_time
+    segment = mock('segment')
+    segment.expects(:metric_name).twice.returns('Controller/foo')
+    segment.expects(:duration).returns(0.1)
+    segment.expects(:exclusive_duration).returns(0)
+    @ss << segment
+    segment.expects(:exclusive_duration).returns(0.1)
+    @ss.current_nest_count += 1
+    @ss << segment
+    assert_equal 0.1, @ss.total_time
+    assert_equal 0.1, @ss.exclusive_time
+    assert_equal 2, @ss.call_count
+  end
+
+  def test_ui_name_default
+    @ss.metric_name = 'Remainder'
+    assert_equal 'Remainder', @ss.ui_name
+  end
+
+  def test_ui_name_lookup
+    mocked_object = mock('metric parser obj')
+    mocked_object.expects(:developer_name).returns('Developer Name')
+    Mmtrix::MetricParser::MetricParser.expects(:parse).with('Controller/foo').returns(mocked_object)
+    assert_equal 'Developer Name', @ss.ui_name
+  end
+end