newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -31,14 +31,18 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     agent.stubs(:stats_engine).returns(stats_engine)
     @sampler = NewRelic::Agent::TransactionSampler.new
     stats_engine.transaction_sampler = @sampler
+    @old_sampler = NewRelic::Agent.instance.transaction_sampler
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_sampler, @sampler)
     @test_config = { :'transaction_tracer.enabled' => true }
     NewRelic::Agent.config.apply_config(@test_config)
+    @txn = stub('txn', :name => '/path', :custom_parameters => {})
   end
 
   def teardown
     super
     Thread.current[:transaction_sample_builder] = nil
     NewRelic::Agent.config.remove_config(@test_config)
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_sampler, @old_sampler)
   end
 
   def test_initialize
@@ -97,25 +101,25 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def test_notice_push_scope_no_builder
     @sampler.expects(:builder)
-    assert_equal(nil, @sampler.notice_push_scope('a scope'))
+    assert_equal(nil, @sampler.notice_push_scope())
   end
 
   def test_notice_push_scope_with_builder
     with_config(:developer_mode => false) do
       builder = mock('builder')
-      builder.expects(:trace_entry).with('a scope', 100.0)
+      builder.expects(:trace_entry).with(100.0)
       @sampler.expects(:builder).returns(builder).twice
-      @sampler.notice_push_scope('a scope', Time.at(100))
+      @sampler.notice_push_scope(Time.at(100))
     end
   end
 
   def test_notice_push_scope_in_dev_mode
     builder = mock('builder')
-    builder.expects(:trace_entry).with('a scope', 100.0)
+    builder.expects(:trace_entry).with(100.0)
     @sampler.expects(:builder).returns(builder).twice
     @sampler.expects(:capture_segment_trace)
 
-    @sampler.notice_push_scope('a scope', Time.at(100))
+    @sampler.notice_push_scope(Time.at(100))
   end
 
   def test_scope_depth_no_builder
@@ -161,7 +165,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def test_notice_scope_empty_no_builder
     @sampler.expects(:builder).returns(nil)
-    assert_equal(nil, @sampler.notice_scope_empty)
+    assert_equal(nil, @sampler.notice_scope_empty(@txn))
   end
 
   def test_notice_scope_empty_ignored_transaction
@@ -169,31 +173,34 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     # the builder should be cached, so only called once
     @sampler.expects(:builder).returns(builder).once
 
-    builder.expects(:finish_trace).with(100.0)
+    builder.expects(:finish_trace).with(100.0, {})
 
     @sampler.expects(:clear_builder)
 
     builder.expects(:ignored?).returns(true)
+    builder.expects(:set_transaction_name).returns(true)
 
-    assert_equal(nil, @sampler.notice_scope_empty(Time.at(100)))
+    assert_equal(nil, @sampler.notice_scope_empty(@txn, Time.at(100)))
   end
 
   def test_notice_scope_empty_with_builder
     builder = mock('builder')
-    # the builder should be cached, so only called once
-    @sampler.expects(:builder).returns(builder).once
+    @sampler.stubs(:builder).returns(builder)
 
 
-    builder.expects(:finish_trace).with(100.0)
+    builder.expects(:finish_trace).with(100.0, {})
     @sampler.expects(:clear_builder)
 
     builder.expects(:ignored?).returns(false)
+    builder.expects(:set_transaction_info).returns(true)
+    builder.expects(:set_transaction_name).returns(true)
 
     sample = mock('sample')
     builder.expects(:sample).returns(sample)
     @sampler.expects(:store_sample).with(sample)
 
-    @sampler.notice_scope_empty(Time.at(100))
+    @sampler.notice_transaction(nil, {})
+    @sampler.notice_scope_empty(@txn, Time.at(100))
 
     assert_equal(sample, @sampler.instance_variable_get('@last_sample'))
   end
@@ -303,28 +310,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert_equal([2, 3], @sampler.instance_variable_get('@samples'))
   end
 
-  def test_notice_transaction_disabled
-    builder = mock('builder')
-    builder.expects(:set_transaction_info).never # since we're disabled
-    @sampler.stubs(:builder).returns(builder)
-    with_config(:'transaction_tracer.enabled' => false,
-                :developer_mode => false) do
-      @sampler.notice_transaction('foo')
-    end
-  end
-
-  def test_notice_transaction_no_builder
-    @sampler.expects(:builder).returns(nil).once
-    @sampler.notice_transaction('foo')
-  end
-
-  def test_notice_transaction_with_builder
-    builder = mock('builder')
-    builder.expects(:set_transaction_info).with('a path', 'a uri', {:some => :params})
-    @sampler.expects(:builder).returns(builder).twice
-    @sampler.notice_transaction('a path', 'a uri', {:some => :params})
-  end
-
   def test_ignore_transaction_no_builder
     @sampler.expects(:builder).returns(nil).once
     @sampler.ignore_transaction
@@ -671,21 +656,20 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   def test_sample_tree
     with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
       assert_equal 0, @sampler.scope_depth
-
       @sampler.notice_first_scope_push Time.now.to_f
-      @sampler.notice_transaction "/path", nil, {}
-      @sampler.notice_push_scope "a"
+      @sampler.notice_transaction(nil, {})
+      @sampler.notice_push_scope
 
-      @sampler.notice_push_scope "b"
+      @sampler.notice_push_scope
       @sampler.notice_pop_scope "b"
 
-      @sampler.notice_push_scope "c"
-      @sampler.notice_push_scope "d"
+      @sampler.notice_push_scope
+      @sampler.notice_push_scope
       @sampler.notice_pop_scope "d"
       @sampler.notice_pop_scope "c"
 
       @sampler.notice_pop_scope "a"
-      @sampler.notice_scope_empty
+      @sampler.notice_scope_empty(@txn)
       sample = @sampler.harvest([]).first
       assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
     end
@@ -700,19 +684,19 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
     with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
       @sampler.notice_first_scope_push Time.now.to_f
-      @sampler.notice_transaction "/path", nil, {}
-      @sampler.notice_push_scope "a"
+      @sampler.notice_transaction(nil, {})
+      @sampler.notice_push_scope
 
-      @sampler.notice_push_scope "b"
+      @sampler.notice_push_scope
       @sampler.notice_pop_scope "b"
 
-      @sampler.notice_push_scope "c"
-      @sampler.notice_push_scope "d"
+      @sampler.notice_push_scope
+      @sampler.notice_push_scope
       @sampler.notice_pop_scope "d"
       @sampler.notice_pop_scope "c"
 
       @sampler.notice_pop_scope "a"
-      @sampler.notice_scope_empty
+      @sampler.notice_scope_empty(@txn)
 
       sample = @sampler.harvest([]).first
       assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
@@ -789,23 +773,22 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   def test_sample_with_parallel_paths
     with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
       assert_equal 0, @sampler.scope_depth
-
       @sampler.notice_first_scope_push Time.now.to_f
-      @sampler.notice_transaction "/path", nil, {}
-      @sampler.notice_push_scope "a"
+      @sampler.notice_transaction(nil, {})
+      @sampler.notice_push_scope
 
       assert_equal 1, @sampler.scope_depth
 
       @sampler.notice_pop_scope "a"
-      @sampler.notice_scope_empty
+      @sampler.notice_scope_empty(@txn)
 
       assert_equal 0, @sampler.scope_depth
 
       @sampler.notice_first_scope_push Time.now.to_f
-      @sampler.notice_transaction "/path", nil, {}
-      @sampler.notice_push_scope "a"
+      @sampler.notice_transaction(nil, {})
+      @sampler.notice_push_scope
       @sampler.notice_pop_scope "a"
-      @sampler.notice_scope_empty
+      @sampler.notice_scope_empty(@txn)
 
       assert_equal 0, @sampler.scope_depth
       sample = @sampler.harvest(nil).first
@@ -816,13 +799,13 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   def test_double_scope_stack_empty
     with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
       @sampler.notice_first_scope_push Time.now.to_f
-      @sampler.notice_transaction "/path", nil, {}
-      @sampler.notice_push_scope "a"
+      @sampler.notice_transaction(nil, {})
+      @sampler.notice_push_scope
       @sampler.notice_pop_scope "a"
-      @sampler.notice_scope_empty
-      @sampler.notice_scope_empty
-      @sampler.notice_scope_empty
-      @sampler.notice_scope_empty
+      @sampler.notice_scope_empty(@txn)
+      @sampler.notice_scope_empty(@txn)
+      @sampler.notice_scope_empty(@txn)
+      @sampler.notice_scope_empty(@txn)
 
       assert_not_nil @sampler.harvest(nil)[0]
     end
@@ -856,7 +839,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     with_config(:'transaction_tracer.stack_trace_threshold' => 0) do
       t = Time.now
       @sampler.notice_first_scope_push t.to_f
-      @sampler.notice_push_scope 'Bill', (t+1).to_f
+      @sampler.notice_push_scope((t+1).to_f)
 
       segment = @sampler.send(:builder).current_segment
       assert segment[:backtrace]
@@ -894,7 +877,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def test_segment_obfuscated
     @sampler.notice_first_scope_push Time.now.to_f
-    @sampler.notice_push_scope "foo"
+    @sampler.notice_push_scope
 
     orig_sql = "SELECT * from Jim where id=66"
 
@@ -912,12 +895,12 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
       with_config(:capture_params => capture) do
         tt = with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
           @sampler.notice_first_scope_push Time.now.to_f
-          @sampler.notice_transaction('/path', nil, {:param => 'hi'})
-          @sampler.notice_scope_empty
+          @sampler.notice_transaction(nil, :param => 'hi')
+          @sampler.notice_scope_empty(@txn)
           @sampler.harvest(nil)[0]
         end
 
-        assert_equal (capture) ? 1 : 0, tt.params[:request_params].length
+        assert_equal (capture ? 1 : 0), tt.params[:request_params].length
       end
     end
   end
@@ -925,9 +908,9 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   def test_should_not_collect_segments_beyond_limit
     with_config(:'transaction_tracer.limit_segments' => 3) do
       run_sample_trace do
-        @sampler.notice_push_scope 'a1'
+        @sampler.notice_push_scope
         @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'hallah'", nil, 0)
-        @sampler.notice_push_scope 'a11'
+        @sampler.notice_push_scope
         @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'semolina'", nil, 0)
         @sampler.notice_pop_scope "a11"
         @sampler.notice_pop_scope "a1"
@@ -938,8 +921,8 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def test_renaming_current_segment_midflight
     @sampler.start_builder
-    @sampler.notice_push_scope( 'External/www.google.com/all' )
-    @sampler.rename_scope_segment( 'External/www.google.com/Net::HTTP/GET' )
+    segment = @sampler.notice_push_scope
+    segment.metric_name = 'External/www.google.com/Net::HTTP/GET'
     assert_nothing_raised do
       @sampler.notice_pop_scope( 'External/www.google.com/Net::HTTP/GET' )
     end
@@ -947,26 +930,48 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def test_adding_segment_parameters
     @sampler.start_builder
-    @sampler.notice_push_scope( 'External/www.google.com/all' )
+    @sampler.notice_push_scope
     @sampler.add_segment_parameters( :transaction_guid => '97612F92E6194080' )
     assert_equal '97612F92E6194080', @sampler.builder.current_segment[:transaction_guid]
   end
 
+  class Dummy
+    include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    def run(n)
+      n.times do
+        perform_action_with_newrelic_trace("smile") do
+        end
+      end
+    end
+  end
+
+  # TODO: this test seems to be destabilizing CI in a way that I don't grok.
+  def sadly_do_not_test_harvest_during_transaction_safety
+    n = 3000
+    harvester = Thread.new do
+      n.times { @sampler.harvest }
+    end
+
+    assert_nothing_raised { Dummy.new.run(n) }
+
+    harvester.join
+  end
+
   private
 
   def run_sample_trace(start = Time.now.to_f, stop = nil)
+    @sampler.notice_transaction(nil, {})
     @sampler.notice_first_scope_push start
-    @sampler.notice_transaction '/path', nil, {}
-    @sampler.notice_push_scope "a"
+    @sampler.notice_push_scope
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'wheat'", nil, 0)
-    @sampler.notice_push_scope "ab"
+    @sampler.notice_push_scope
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'white'", nil, 0)
     yield if block_given?
     @sampler.notice_pop_scope "ab"
-    @sampler.notice_push_scope "ac"
+    @sampler.notice_push_scope
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", nil, 0)
     @sampler.notice_pop_scope "ac"
     @sampler.notice_pop_scope "a"
-    @sampler.notice_scope_empty stop || Time.now.to_f
+    @sampler.notice_scope_empty(@txn, (stop || Time.now.to_f))
   end
 end

data/test/new_relic/agent/{instrumentation/metric_frame_test.rb → transaction_test.rb}

@@ -2,65 +2,70 @@
 # 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 File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 
-class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
+class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
+
+  attr_reader :txn
 
-  attr_reader :f
   def setup
-    @f = NewRelic::Agent::Instrumentation::MetricFrame.new
+    @txn = NewRelic::Agent::Transaction.new
   end
 
   def test_request_parsing__none
-    assert_nil f.uri
-    assert_nil f.referer
+    assert_nil txn.uri
+    assert_nil txn.referer
   end
+
   def test_request_parsing__path
     request = stub(:path => '/path?hello=bob#none')
-    f.request = request
-    assert_equal "/path", f.uri
+    txn.request = request
+    assert_equal "/path", txn.uri
   end
+
   def test_request_parsing__fullpath
     request = stub(:fullpath => '/path?hello=bob#none')
-    f.request = request
-    assert_equal "/path", f.uri
+    txn.request = request
+    assert_equal "/path", txn.uri
   end
+
   def test_request_parsing__referer
     request = stub(:referer => 'https://www.yahoo.com:8080/path/hello?bob=none&foo=bar')
-    f.request = request
-    assert_nil f.uri
-    assert_equal "https://www.yahoo.com:8080/path/hello", f.referer
+    txn.request = request
+    assert_nil txn.uri
+    assert_equal "https://www.yahoo.com:8080/path/hello", txn.referer
   end
 
   def test_request_parsing__uri
     request = stub(:uri => 'http://creature.com/path?hello=bob#none', :referer => '/path/hello?bob=none&foo=bar')
-    f.request = request
-    assert_equal "/path", f.uri
-    assert_equal "/path/hello", f.referer
+    txn.request = request
+    assert_equal "/path", txn.uri
+    assert_equal "/path/hello", txn.referer
   end
 
   def test_request_parsing__hostname_only
     request = stub(:uri => 'http://creature.com')
-    f.request = request
-    assert_equal "/", f.uri
-    assert_nil f.referer
+    txn.request = request
+    assert_equal "/", txn.uri
+    assert_nil txn.referer
   end
+
   def test_request_parsing__slash
     request = stub(:uri => 'http://creature.com/')
-    f.request = request
-    assert_equal "/", f.uri
-    assert_nil f.referer
+    txn.request = request
+    assert_equal "/", txn.uri
+    assert_nil txn.referer
   end
 
   def test_queue_time
-    f.apdex_start = 1000
-    f.start = 1500
-    assert_equal 500, f.queue_time
+    txn.apdex_start = 1000
+    txn.start_time = 1500
+    assert_equal 500, txn.queue_time
   end
 
   def test_update_apdex_records_failed_when_specified
     stats = NewRelic::Agent::Stats.new
-    NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.1, true)
+    NewRelic::Agent::Transaction.update_apdex(stats, 0.1, true)
     assert_equal 0, stats.apdex_s
     assert_equal 0, stats.apdex_t
     assert_equal 1, stats.apdex_f
@@ -69,7 +74,7 @@ class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
   def test_update_apdex_records_satisfying
     stats = NewRelic::Agent::Stats.new
     with_config(:apdex_t => 1) do
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.5, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 0.5, false)
     end
     assert_equal 1, stats.apdex_s
     assert_equal 0, stats.apdex_t
@@ -79,7 +84,7 @@ class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
   def test_update_apdex_records_tolerating
     stats = NewRelic::Agent::Stats.new
     with_config(:apdex_t => 1) do
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 1.5, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 1.5, false)
     end
     assert_equal 0, stats.apdex_s
     assert_equal 1, stats.apdex_t
@@ -89,7 +94,7 @@ class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
   def test_update_apdex_records_failing
     stats = NewRelic::Agent::Stats.new
     with_config(:apdex_t => 1) do
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 4.5, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 4.5, false)
     end
     assert_equal 0, stats.apdex_s
     assert_equal 0, stats.apdex_t
@@ -107,31 +112,31 @@ class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
       :apdex => 1
     }
 
-    txn_info.transaction_name = 'Controller/slow/txn'
+    txn_info.transaction.name = 'Controller/slow/txn'
     with_config(config, :do_not_cast => true) do
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 3.5, false)
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 5.5, false)
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 16.5, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 3.5, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 5.5, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 16.5, false)
     end
     assert_equal 1, stats.apdex_s
     assert_equal 1, stats.apdex_t
     assert_equal 1, stats.apdex_f
 
-    txn_info.transaction_name = 'Controller/fast/txn'
+    txn_info.transaction.name = 'Controller/fast/txn'
     with_config(config, :do_not_cast => true) do
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.05, false)
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.2, false)
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.5, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 0.05, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 0.2, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 0.5, false)
     end
     assert_equal 2, stats.apdex_s
     assert_equal 2, stats.apdex_t
     assert_equal 2, stats.apdex_f
 
-    txn_info.transaction_name = 'Controller/other/txn'
+    txn_info.transaction.name = 'Controller/other/txn'
     with_config(config, :do_not_cast => true) do
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.5, false)
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 2, false)
-      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 5, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 0.5, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 2, false)
+      NewRelic::Agent::Transaction.update_apdex(stats, 5, false)
     end
     assert_equal 3, stats.apdex_s
     assert_equal 3, stats.apdex_t
@@ -145,11 +150,40 @@ class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
     NewRelic::Agent.instance.instance_variable_set(:@stats_engine, stats_engine)
 
     with_config(:apdex_t => 2.5) do
-      NewRelic::Agent::Instrumentation::MetricFrame.record_apdex(metric, 1, 1, false)
+      NewRelic::Agent::Transaction.record_apdex(metric, 1, 1, false)
     end
     assert_equal 2.5, stats_engine.lookup_stats('Apdex').min_call_time
     assert_equal 2.5, stats_engine.lookup_stats('Apdex').max_call_time
     assert_equal 2.5, stats_engine.lookup_stats('Apdex/Controller/some/txn').min_call_time
     assert_equal 2.5, stats_engine.lookup_stats('Apdex/Controller/some/txn').max_call_time
   end
+
+  def test_start_adds_controller_context_to_txn_stack
+    NewRelic::Agent::Transaction.start(:controller)
+    assert_equal 1, NewRelic::Agent::Transaction.stack.size
+
+    NewRelic::Agent::Transaction.start(:controller)
+    assert_equal 2, NewRelic::Agent::Transaction.stack.size
+
+    NewRelic::Agent::Transaction.stop('txn')
+    assert_equal 1, NewRelic::Agent::Transaction.stack.size
+
+    NewRelic::Agent::Transaction.stop('txn')
+    assert_equal 0, NewRelic::Agent::Transaction.stack.size
+  end
+
+  def test_end_applies_transaction_name_rules
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                  'replacement'      => '*',
+                                                  'replace_all'      => true)
+    NewRelic::Agent.instance.transaction_rules << rule
+    NewRelic::Agent::Transaction.start(:controller)
+    NewRelic::Agent.set_transaction_name('foo/1/bar/22')
+    NewRelic::Agent::Transaction.freeze_name
+    txn = NewRelic::Agent::Transaction.stop('txn')
+    assert_equal 'Controller/foo/*/bar/*', txn.name
+  ensure
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
+                                              NewRelic::Agent::RulesEngine.new)
+  end
 end

data/test/new_relic/agent/uri_util_test.rb

@@ -0,0 +1,75 @@
+# 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/agent_logger'
+require 'new_relic/agent/null_logger'
+
+class URIUtilTest < Test::Unit::TestCase
+  def setup
+    fixture_tcp_socket(nil)
+  end
+
+  def dummy_request(uri_string, opts={})
+    uri = URI(uri_string)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = opts.has_key?(:use_ssl) ? opts[:use_ssl] : false
+    req = Net::HTTP::Get.new(opts[:path] || uri.request_uri)
+    [http, req]
+  end
+
+  def filter(uri_string, opts={})
+    NewRelic::Agent::URIUtil.filtered_uri_for(*dummy_request(uri_string, opts))
+  end
+
+  def test_filtered_uri_for
+    uri = "http://foo.com/bar/baz"
+    assert_equal("http://foo.com/bar/baz", filter(uri))
+  end
+
+  def test_filtered_uri_for_custom_port
+    uri = "http://foo.com:1234/bar/baz"
+    assert_equal("http://foo.com:1234/bar/baz", filter(uri))
+  end
+
+  def test_filtered_uri_omits_query_params
+    uri = "http://foo.com/bar/baz?a=1&b=2"
+    assert_equal("http://foo.com/bar/baz", filter(uri))
+  end
+
+  def test_filtered_uri_omits_fragment
+    uri = "http://foo.com/bar/baz#fragment"
+    assert_equal("http://foo.com/bar/baz", filter(uri, :path => '/bar/baz#fragment'))
+  end
+
+  def test_filtered_uri_omits_query_params_and_fragment
+    uri = "http://foo.com/bar/baz?a=1&b=2#fragment"
+    assert_equal("http://foo.com/bar/baz", filter(uri, :path => '/bar/baz?a=1&b=2#fragment'))
+  end
+
+  def test_filtered_uri_reflects_use_of_ssl
+    uri = 'https://foo.com/bar/baz'
+    assert_equal("https://foo.com/bar/baz", filter(uri, :use_ssl => true))
+  end
+
+  def test_filtered_uri_reflects_use_of_ssl_with_custom_port
+    uri = 'https://foo.com:9999/bar/baz'
+    assert_equal("https://foo.com:9999/bar/baz", filter(uri, :use_ssl => true))
+  end
+
+  def test_filtered_uri_for_with_full_uri_request_path
+    uri = "http://foo.com/bar/baz?a=1&b=2#fragment"
+    assert_equal("http://foo.com/bar/baz", filter(uri, :path => uri))
+  end
+
+  def test_filtered_uri_for_with_full_uri_request_path_https
+    uri = "https://foo.com/bar/baz?a=1&b=2#fragment"
+    assert_equal("https://foo.com/bar/baz", filter(uri, :path => uri, :use_ssl => true))
+  end
+
+  def test_strips_credentials_embedded_in_uri
+    uri = "http://user:pass@foo.com/bar/baz"
+    assert_equal("http://foo.com/bar/baz", filter(uri, :path => uri))
+  end
+end