newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -29,13 +29,11 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     NewRelic::Agent.instance.instance_eval do
       @beacon_configuration = NewRelic::Agent::BeaconConfiguration.new
     end
+  end
 
   def teardown
-    Thread.current[:last_metric_frame] = nil
     NewRelic::Agent::TransactionInfo.clear
     NewRelic::Agent.config.remove_config(@config)
-  end
-
     mocha_teardown
   end
 
@@ -208,9 +206,11 @@ var e=document.createElement("script");'
   end
 
   def test_browser_monitoring_transaction_name_basic
-    mock = mock('transaction sample')
+    mock = stub_everything('transaction info')
     NewRelic::Agent::TransactionInfo.set(mock)
-    mock.stubs(:transaction_name).returns('a transaction name')
+    txn = NewRelic::Agent::Transaction.new
+    txn.name = 'a transaction name'
+    mock.stubs(:transaction).returns(txn)
 
     assert_equal('a transaction name', browser_monitoring_transaction_name, "should take the value from the thread local")
   end
@@ -219,7 +219,7 @@ var e=document.createElement("script");'
     mock = mock('transaction sample')
     NewRelic::Agent::TransactionInfo.set(mock)
 
-    mock.stubs(:transaction_name).returns('')
+    mock.stubs(:transaction).returns(stub(:name => ''))
     assert_equal('', browser_monitoring_transaction_name, "should take the value even when it is empty")
   end
 
@@ -266,49 +266,59 @@ var e=document.createElement("script");'
   end
 
   def test_browser_monitoring_queue_time_zero
-    frame = Thread.current[:last_metric_frame] = mock('metric frame')
-    frame.expects(:queue_time).returns(0.0)
-    assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is zero queue time')
+    in_transaction do
+      NewRelic::Agent::Transaction.current.expects(:queue_time).returns(0.0)
+      assert_equal(0.0, browser_monitoring_queue_time,
+                   'should return zero when there is zero queue time')
+    end
   end
 
   def test_browser_monitoring_queue_time_ducks
-    frame = Thread.current[:last_metric_frame] = mock('metric frame')
-    frame.expects(:queue_time).returns('a duck')
-    assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is an incorrect queue time')
+    in_transaction do
+      NewRelic::Agent::Transaction.current.expects(:queue_time) \
+        .returns('a duck')
+      assert_equal(0.0, browser_monitoring_queue_time,
+                   'should return zero when there is an incorrect queue time')
+    end
   end
 
   def test_browser_monitoring_queue_time_nonzero
-    frame = Thread.current[:last_metric_frame] = mock('metric frame')
-    frame.expects(:queue_time).returns(3.00002)
-    assert_equal(3000, browser_monitoring_queue_time, 'should return a rounded time')
+    in_transaction do
+      NewRelic::Agent::Transaction.current.expects(:queue_time) \
+        .returns(3.00002)
+      assert_equal(3000, browser_monitoring_queue_time,
+                   'should return a rounded time')
+    end
   end
 
   def test_footer_js_string_basic
     # mocking this because JRuby thinks that Time.now - Time.now
     # always takes at least 1ms
     self.expects(:browser_monitoring_app_time).returns(0)
-    frame = Thread.current[:last_metric_frame] = mock('metric frame')
-    user_attributes = {:user => "user", :account => "account", :product => "product"}
-    frame.expects(:user_attributes).returns(user_attributes).at_least_once
-    frame.expects(:queue_time).returns(0)
-
-    sample = mock('transaction info')
-    NewRelic::Agent::TransactionInfo.set(sample)
-
-    sample.stubs(:start_time).returns(Time.at(100))
-    sample.stubs(:guid).returns('ABC')
-    sample.stubs(:transaction_name).returns('most recent transaction')
-    sample.stubs(:include_guid?).returns(true)
-    sample.stubs(:duration).returns(12.0)
-    sample.stubs(:token).returns('0123456789ABCDEF')
-
-    self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'most recent transaction').returns('most recent transaction')
-    self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'user').returns('user')
-    self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'account').returns('account')
-    self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'product').returns('product')
-
-    value = footer_js_string(NewRelic::Agent.instance.beacon_configuration)
-    assert_equal(%'<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push(["load",new Date().getTime()]);\nvar e=document.createElement("script");\ne.type="text/javascript";\ne.src=(("http:"===document.location.protocol)?"http:":"https:") + "//" +\n  "this_is_my_file";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push(["nrfj","beacon","browserKey","5, 6","most recent transaction",0,0,new Date().getTime(),"ABC","0123456789ABCDEF","user","account","product"]);</script>', value, "should return the javascript given some default values")
+    in_transaction do
+      txn = NewRelic::Agent::Transaction.current
+      user_attributes = {:user => "user", :account => "account", :product => "product"}
+      txn.expects(:user_attributes).returns(user_attributes).at_least_once
+      txn.expects(:queue_time).returns(0)
+      txn.name = 'most recent transaction'
+
+      sample = stub_everything('transaction info',
+                               :start_time => Time.at(100),
+                               :guid => 'ABC',
+                               :transaction => txn,
+                               :include_guid? => true,
+                               :duration => 12.0,
+                               :token => '0123456789ABCDEF')
+      NewRelic::Agent::TransactionInfo.set(sample)
+
+      self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'most recent transaction').returns('most recent transaction')
+      self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'user').returns('user')
+      self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'account').returns('account')
+      self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'product').returns('product')
+
+      value = footer_js_string(NewRelic::Agent.instance.beacon_configuration)
+      assert_equal(%'<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push(["load",new Date().getTime()]);\nvar e=document.createElement("script");\ne.type="text/javascript";\ne.src=(("http:"===document.location.protocol)?"http:":"https:") + "//" +\n  "this_is_my_file";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push(["nrfj","beacon","browserKey","5, 6","most recent transaction",0,0,new Date().getTime(),"ABC","0123456789ABCDEF","user","account","product"]);</script>', value, "should return the javascript given some default values")
+    end
   end
 
   def test_html_safe_if_needed_unsafed
@@ -386,10 +396,22 @@ var e=document.createElement("script");'
     assert_equal expected_payload, response['X-NewRelic-App-Server-Metrics'].strip
   end
 
+  def test_freezes_transaction_name_when_footer_is_written
+    with_config(:license_key => 'a' * 13) do
+      in_transaction do
+        assert !NewRelic::Agent::Transaction.current.name_frozen?
+        browser_timing_footer
+        assert NewRelic::Agent::Transaction.current.name_frozen?
+      end
+    end
+  end
+
   def mobile_transaction(request=nil)
     request ||= Rack::Request.new('X-NewRelic-Mobile-Trace' => 'true')
     response = Rack::Response.new
-    txn_data = OpenStruct.new(:transaction_name => 'a transaction name',
+    txn = NewRelic::Agent::Transaction.new
+    txn.name = 'a transaction name'
+    txn_data = OpenStruct.new(:transaction => txn,
                               :start_time => 5,
                               :force_persist_sample? => false)
     NewRelic::Agent::TransactionInfo.set(txn_data)

data/test/new_relic/agent/configuration/environment_source_test.rb

@@ -34,24 +34,26 @@ module NewRelic::Agent::Configuration
       assert_applied_symbol 'NEWRELIC_FRAMEWORK', 'framework'
     end
 
-    def test_environment_booleans_truths_are_applied
-      ENV['NEWRELIC_ENABLE'] = 'true'
-      assert EnvironmentSource.new[:agent_enabled]
-      ENV['NEWRELIC_ENABLE'] = 'on'
-      assert EnvironmentSource.new[:agent_enabled]
-      ENV['NEWRELIC_ENABLE'] = 'yes'
-      assert EnvironmentSource.new[:agent_enabled]
-      ENV.delete('NEWRELIC_ENABLE')
-    end
+    %w| NEWRELIC_ENABLE NEWRELIC_ENABLED NEW_RELIC_ENABLE NEW_RELIC_ENABLED |.each do |var|
+      define_method("test_environment_booleans_truths_are_applied_to_#{var}") do
+        ENV[var] = 'true'
+        assert EnvironmentSource.new[:agent_enabled]
+        ENV[var] = 'on'
+        assert EnvironmentSource.new[:agent_enabled]
+        ENV[var] = 'yes'
+        assert EnvironmentSource.new[:agent_enabled]
+        ENV.delete(var)
+      end
 
-    def test_environment_booleans_falsehoods_are_applied
-      ENV['NEWRELIC_ENABLE'] = 'false'
-      assert !EnvironmentSource.new[:agent_enabled]
-      ENV['NEWRELIC_ENABLE'] = 'off'
-      assert !EnvironmentSource.new[:agent_enabled]
-      ENV['NEWRELIC_ENABLE'] = 'no'
-      assert !EnvironmentSource.new[:agent_enabled]
-      ENV.delete('NEWRELIC_ENABLE')
+      define_method("test_environment_booleans_falsehoods_are_applied_to_#{var}") do
+        ENV[var] = 'false'
+        assert !EnvironmentSource.new[:agent_enabled]
+        ENV[var] = 'off'
+        assert !EnvironmentSource.new[:agent_enabled]
+        ENV[var] = 'no'
+        assert !EnvironmentSource.new[:agent_enabled]
+        ENV.delete(var)
+      end
     end
 
     def test_set_log_config_from_environment

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -198,6 +198,14 @@ module NewRelic::Agent
       assert_equal str, decoded
     end
 
+    def test_setting_response_headers_freezes_transaction_name
+      in_transaction do
+        assert !NewRelic::Agent::Transaction.current.name_frozen?
+        when_request_runs
+        assert NewRelic::Agent::Transaction.current.name_frozen?
+      end
+    end
+
     #
     # Helpers
     #

data/test/new_relic/agent/error_collector/notice_error_test.rb

@@ -175,10 +175,6 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
     error = nil
     with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
       error_collector.expects(:error_is_ignored?).with(error).returns(false)
-      # we increment it for the case that someone calls
-      # NewRelic::Agent.notice_error(foo) # foo is nil
-      # (which is probably not a good idea but is the existing api)
-      error_collector.expects(:increment_error_count!)
       assert error_collector.should_exit_notice_error?(error)
     end
   end
@@ -195,7 +191,6 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
     error = mocked_error
     with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
       error_collector.expects(:error_is_ignored?).with(error).returns(false)
-      error_collector.expects(:increment_error_count!)
       assert !error_collector.should_exit_notice_error?(error)
     end
   end

data/test/new_relic/agent/error_collector_test.rb

@@ -197,13 +197,12 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_increment_error_count_record_summary_and_txn_metric
-    txn_info = NewRelic::Agent::TransactionInfo.new
-    txn_info.transaction_name = 'Controller/class/method'
-    NewRelic::Agent::TransactionInfo.stubs(:get).returns(txn_info)
-
     stats_engine = NewRelic::Agent.instance.stats_engine
     stats_engine.reset_stats
-    @error_collector.increment_error_count!(StandardError.new('Boo'))
+
+    @error_collector.increment_error_count!(StandardError.new('Boo'),
+                                            :metric => 'Controller/class/method')
+
     assert_equal(1, stats_engine.get_stats('Errors/all').call_count,
                  'Missing Errors/all metric')
     assert_equal(1, stats_engine.get_stats('Errors/Controller/class/method').call_count,
@@ -211,12 +210,12 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_doesnt_increment_error_count_on_transaction_if_nameless
-    txn_info = NewRelic::Agent::TransactionInfo.new
-    NewRelic::Agent::TransactionInfo.stubs(:get).returns(txn_info)
-
     stats_engine = NewRelic::Agent.instance.stats_engine
     stats_engine.reset_stats
-    @error_collector.increment_error_count!(StandardError.new('Boo'))
+
+    @error_collector.increment_error_count!(StandardError.new('Boo'),
+                                            :metric => '(unknown)')
+
     assert_equal(0, stats_engine.get_stats('Errors/(unknown)').call_count)
   end
 

data/test/new_relic/agent/instrumentation/action_controller_subscriber_test.rb

@@ -0,0 +1,228 @@
+# 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/instrumentation/action_controller_subscriber'
+
+class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Test::Unit::TestCase
+  class TestController
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+    def self.controller_path
+      'test'
+    end
+
+    def action_name
+      'test'
+    end
+
+    newrelic_ignore :only => :ignored_action
+    newrelic_ignore_apdex :only => :ignored_apdex
+    newrelic_ignore_enduser :only => :ignored_enduser
+  end
+
+  def setup
+    @subscriber = NewRelic::Agent::Instrumentation::ActionControllerSubscriber.new
+    NewRelic::Agent.instance.stats_engine.clear_stats
+    @entry_payload = {
+      :controller => TestController.to_s,
+      :action => 'index',
+      :format => :html,
+      :method => 'GET',
+      :path => '/tests',
+      :params => { :controller => 'test_controller', :action => 'index' },
+    }
+    @exit_payload = @entry_payload.merge(:status => 200, :view_runtime => 5.0,
+                                         :db_runtime => 0.5 )
+    @stats_engine = NewRelic::Agent.instance.stats_engine
+    @stats_engine.clear_stats
+    NewRelic::Agent.manual_start
+  end
+
+  def teardown
+    NewRelic::Agent.shutdown
+    @stats_engine.clear_stats
+  end
+
+  def test_record_controller_metrics
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0 + 2)
+
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_equal 1, @stats_engine.lookup_stats('Controller/test/index').call_count
+    assert_equal 1, @stats_engine.lookup_stats('HttpDispatcher').call_count
+    assert_equal 2.0, @stats_engine.lookup_stats('Controller/test/index').total_call_time
+    assert_equal 2.0, @stats_engine.lookup_stats('HttpDispatcher').total_call_time
+  end
+
+  def test_record_apdex_metrics
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0 + 1.5)
+
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    apdex_metric = @stats_engine.lookup_stats('Apdex/test/index')
+    apdex_rollup_metric = @stats_engine.lookup_stats('Apdex')
+    assert_equal 0, apdex_metric.apdex_f
+    assert_equal 0, apdex_rollup_metric.apdex_f
+    assert_equal 1, apdex_metric.apdex_t
+    assert_equal 1, apdex_rollup_metric.apdex_t
+    assert_equal 0, apdex_metric.apdex_s
+    assert_equal 0, apdex_rollup_metric.apdex_s
+  end
+
+  def test_records_scoped_metrics_for_evented_child_txn
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.start('process_action.action_controller', :id, @entry_payload \
+                        .merge(:action => 'child', :path => '/child'))
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload \
+                         .merge(:action => 'child', :path => '/child'))
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_equal(1, @stats_engine.lookup_stats('Controller/test/child',
+                                               'Controller/test/index').call_count)
+  end
+
+  def test_records_scoped_metrics_for_traced_child_txn
+    controller = TestController.new
+    controller.perform_action_with_newrelic_trace(:category => :controller,
+                                                  :name => 'index',
+                                                  :class_name => 'test') do
+      @subscriber.start('process_action.action_controller', :id, @entry_payload \
+                          .merge(:action => 'child', :path => '/child'))
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload \
+                           .merge(:action => 'child', :path => '/child'))
+    end
+
+    assert_equal 1, @stats_engine.lookup_stats('Controller/test/child',
+                                               'Controller/test/index').call_count
+  end
+
+  def test_record_nothing_for_ignored_action
+    @entry_payload[:action] = 'ignored_action'
+    @exit_payload[:action] = 'ignored_action'
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_nil @stats_engine.lookup_stats('Controller/test/ignored_action')
+    assert_nil @stats_engine.lookup_stats('Apdex/test/ignored_action')
+    assert_nil @stats_engine.lookup_stats('Apdex')
+    assert_nil @stats_engine.lookup_stats('HttpDispatcher')
+  end
+
+  def test_record_no_apdex_metric_for_ignored_apdex_action
+    @entry_payload[:action] = 'ignored_apdex'
+    @exit_payload[:action] = 'ignored_apdex'
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert @stats_engine.lookup_stats('Controller/test/ignored_apdex')
+    assert_nil @stats_engine.lookup_stats('Apdex/test/ignored_apdex')
+    assert_nil @stats_engine.lookup_stats('Apdex')
+    assert @stats_engine.lookup_stats('HttpDispatcher')
+  end
+
+  def test_ignore_end_user
+    @entry_payload[:action] = 'ignored_enduser'
+    @exit_payload[:action] = 'ignored_enduser'
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert NewRelic::Agent::TransactionInfo.get.ignore_end_user?
+  end
+
+  def test_record_busy_time
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @stats_engine.lookup_stats('Instance/Busy').call_count
+  end
+
+  def test_creates_transaction
+    NewRelic::Agent.instance.transaction_sampler.reset!
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_equal('Controller/test/index',
+                 NewRelic::Agent.instance.transaction_sampler \
+                   .last_sample.params[:path])
+    assert_equal('Controller/test/index',
+                 NewRelic::Agent.instance.transaction_sampler \
+                   .last_sample.root_segment.called_segments[0].metric_name)
+  end
+
+  def test_applies_txn_name_rules
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => 'test',
+                                                  'replacement'      => 'taste')
+    NewRelic::Agent.instance.transaction_rules << rule
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert NewRelic::Agent.instance.stats_engine \
+      .lookup_stats('Controller/taste/index')
+    assert_nil NewRelic::Agent.instance.stats_engine \
+      .lookup_stats('Controller/test/index')
+  ensure
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
+                                             NewRelic::Agent::RulesEngine.new)
+  end
+
+  def test_record_queue_time_metrics
+    t0 = Time.now
+    Time.stubs(:now).returns(t0)
+    env = { 'HTTP_X_REQUEST_START' => (t0 - 5).to_f.to_s }
+    NewRelic::Agent.instance.events.notify(:before_call, env)
+
+    Time.stubs(:now).returns(t0, t0 + 2)
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    metric = @stats_engine.lookup_stats('WebFrontend/QueueTime')
+    assert_equal 1, metric.call_count
+    assert_in_delta(5.0, metric.total_call_time, 0.1)
+  end
+
+  def test_dont_record_queue_time_if_no_header
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_nil @stats_engine.lookup_stats('WebFrontend/QueueTime')
+  end
+
+  def test_records_request_params_in_txn
+    NewRelic::Agent.instance.transaction_sampler.reset!
+    @entry_payload[:params]['number'] = '666'
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_equal('666',
+                 NewRelic::Agent.instance.transaction_sampler \
+                   .last_sample.params[:request_params]['number'])
+  end
+
+  def test_records_filtered_request_params_in_txn
+    NewRelic::Agent.instance.transaction_sampler.reset!
+    @entry_payload[:params]['password'] = 'secret'
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_equal('[FILTERED]',
+                 NewRelic::Agent.instance.transaction_sampler \
+                   .last_sample.params[:request_params]['password'])
+  end
+
+  def test_records_custom_parameters_in_txn
+    NewRelic::Agent.instance.transaction_sampler.reset!
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    NewRelic::Agent.add_custom_parameters('number' => '666')
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_equal('666',
+                 NewRelic::Agent.instance.transaction_sampler \
+                   .last_sample.params[:custom_params]['number'])
+  end
+end if ::Rails::VERSION::MAJOR.to_i >= 4

data/test/new_relic/agent/instrumentation/action_view_subscriber_test.rb

@@ -2,7 +2,7 @@
 # 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/instrumentation/rails4/action_view'
+require 'new_relic/agent/instrumentation/action_view_subscriber'
 
 class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Test::Unit::TestCase
   def setup
@@ -128,22 +128,19 @@ class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Test::Unit::T
 
   def test_records_scoped_metric
     params = { :identifier => '/root/app/views/model/index.html.erb' }
-    t0 = Time.now
-    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
-    @stats_engine.start_transaction('test_txn')
 
-    @subscriber.start('render_template.action_view', :id, params)
-    @subscriber.start('!render_template.action_view', :id,
-                      :virtual_path => 'model/index')
-    @subscriber.finish('!render_template.action_view', :id,
-                       :virtual_path => 'model/index')
-    @subscriber.finish('render_template.action_view', :id, params)
+    in_transaction('test_txn') do
+      @subscriber.start('render_template.action_view', :id, params)
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/index')
+      @subscriber.finish('!render_template.action_view', :id,
+                         :virtual_path => 'model/index')
+      @subscriber.finish('render_template.action_view', :id, params)
+    end
 
     metric = @stats_engine.lookup_stats('View/model/index.html.erb/Rendering',
                                         'test_txn')
     assert_equal(1, metric.call_count)
-    assert_equal(2.0, metric.total_call_time)
-
   end
 
   def test_records_nothing_if_tracing_disabled
@@ -161,7 +158,7 @@ class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Test::Unit::T
   def test_creates_txn_segment_for_simple_render
     params = { :identifier => '/root/app/views/model/index.html.erb' }
 
-    sampler = in_transaction do
+    in_transaction do
       @subscriber.start('render_template.action_view', :id, params)
       @subscriber.start('!render_template.action_view', :id,
                         :virtual_path => 'model/index')
@@ -171,6 +168,7 @@ class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Test::Unit::T
     end
 
     last_segment = nil
+    sampler = NewRelic::Agent.instance.transaction_sampler
     sampler.last_sample.root_segment.each_segment{|s| last_segment = s }
     NewRelic::Agent.shutdown
 
@@ -179,7 +177,7 @@ class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Test::Unit::T
   end
 
   def test_creates_nested_partial_segment_within_render_segment
-    sampler = in_transaction do
+    in_transaction do
       @subscriber.start('render_template.action_view', :id,
                         :identifier => 'model/index.html.erb')
       @subscriber.start('!render_template.action_view', :id,
@@ -193,12 +191,13 @@ class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Test::Unit::T
       @subscriber.finish('render_partial.action_view', :id,
                          :identifier => '/root/app/views/model/_list.html.erb')
       @subscriber.finish('!render_template.action_view', :id,
-                         :virtual_path => 'model/index')
+                           :virtual_path => 'model/index')
       @subscriber.finish('render_template.action_view', :id,
                          :identifier => 'model/index.html.erb')
     end
 
-    template_segment = sampler.last_sample.root_segment.called_segments[0].called_segments[0]
+    sampler = NewRelic::Agent.instance.transaction_sampler
+    template_segment = sampler.last_sample.root_segment.called_segments[0]
     partial_segment = template_segment.called_segments[0]
 
     assert_equal('View/model/index.html.erb/Rendering',
@@ -208,7 +207,7 @@ class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Test::Unit::T
   end
 
   def test_creates_nodes_for_each_in_a_collection_event
-    sampler = in_transaction do
+    in_transaction do
       @subscriber.start('render_collection.action_view', :id,
                         :identifier => '/root/app/views/model/_list.html.erb',
                         :count => 3)
@@ -229,26 +228,11 @@ class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Test::Unit::T
                          :count => 3)
     end
 
-    template_segment = sampler.last_sample.root_segment.called_segments[0]
-    partial_segments = template_segment.called_segments
+    sampler = NewRelic::Agent.instance.transaction_sampler
+    partial_segments = sampler.last_sample.root_segment.called_segments
 
     assert_equal 3, partial_segments.size
     assert_equal('View/model/_list.html.erb/Partial',
                  partial_segments[0].metric_name)
   end
-
-  def in_transaction
-    NewRelic::Agent.manual_start
-    NewRelic::Agent.instance.stats_engine.start_transaction('test')
-    sampler = NewRelic::Agent.instance.transaction_sampler
-    sampler.notice_first_scope_push(Time.now.to_f)
-    sampler.notice_transaction('/path', '/path', {})
-    sampler.notice_push_scope('Controller/sandwiches/index')
-    yield
-    sampler.notice_pop_scope('Controller/sandwiches/index')
-    sampler.notice_scope_empty
-    sampler
-  ensure
-    NewRelic::Agent.shutdown
-  end
 end if ::Rails::VERSION::MAJOR.to_i >= 4

data/test/new_relic/agent/instrumentation/active_record_instrumentation_test.rb

@@ -68,7 +68,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
 
-    find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"    
+    find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"
 
     assert_calls_metrics(find_metric) do
       ActiveRecordFixtures::Order.exists?(["name=?", 'jeff'])
@@ -211,7 +211,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   end
 
   def test_join_metrics_sqlite
-    return if (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i == 3)
+    return if (defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3)
     return if defined?(JRuby)
     return unless isSqlite?
 
@@ -249,7 +249,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   end
 
   def test_join_metrics_standard
-    return if (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i >= 3)
+    return if (defined?(Rails) && Rails::VERSION::MAJOR.to_i >= 3)
     return if defined?(JRuby) || isSqlite?
 
     expected_metrics = %W[
@@ -290,7 +290,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   end
 
   def test_direct_sql
-    assert_nil NewRelic::Agent::Instrumentation::MetricFrame.current
+    assert_nil NewRelic::Agent::Transaction.current
     assert_nil NewRelic::Agent.instance.stats_engine.scope_name
     assert_equal 0, NewRelic::Agent.instance.stats_engine.metrics.size, NewRelic::Agent.instance.stats_engine.metrics.inspect
 
@@ -549,7 +549,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   private
 
   def rails3?
-    (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i >= 3)
+    (defined?(Rails) && Rails::VERSION::MAJOR.to_i >= 3)
   end
 
   def rails_env