newrelic_rpm 3.7.1.188 → 3.7.2.190.beta

data/test/multiverse/suites/active_record/ar_method_aliasing.rb

@@ -16,84 +16,66 @@ class InstrumentActiveRecordMethods < MiniTest::Unit::TestCase
   include MultiverseHelpers
   setup_and_teardown_agent
 
-  if RUBY_VERSION >= '1.8.7'
-    if RUBY_PLATFORM == 'java'
-      require 'jdbc/sqlite3'
-      @@adapter = 'sqlite3'
-    else
-      require 'sqlite3'
-      @@adapter = 'sqlite3'
-    end
-
-    class User < ActiveRecord::Base
-      include NewRelic::Agent::MethodTracer
-      has_many :aliases
-
-      add_method_tracer :save!
-      add_method_tracer :persisted?
-    end
+  class User < ActiveRecord::Base
+    include NewRelic::Agent::MethodTracer
+    has_many :aliases
 
-    class Alias < ActiveRecord::Base
-      include NewRelic::Agent::MethodTracer
+    add_method_tracer :save!
+    add_method_tracer :persisted?
+  end
 
-      add_method_tracer :save!
-      add_method_tracer :persisted?
-      add_method_tracer :destroyed?
-    end
+  class Alias < ActiveRecord::Base
+    include NewRelic::Agent::MethodTracer
 
-    def after_setup
-      puts "adapter : #{@@adapter}"
-      @db_connection = ActiveRecord::Base.establish_connection( :adapter => @@adapter, :database => "testdb.sqlite3")
-      ActiveRecord::Migration.class_eval do
-        @connection = @db_connection
-        create_table :users do |t|
-              t.string  :name
-        end
+    add_method_tracer :save!
+    add_method_tracer :persisted?
+    add_method_tracer :destroyed?
+  end
 
-        create_table :aliases do |t|
-            t.integer :user_id
-            t.string :aka
-        end
+  def after_setup
+    @db_connection = ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => 'testdb.sqlite3')
+    ActiveRecord::Migration.class_eval do
+      @connection = @db_connection
+      create_table :users do |t|
+        t.string  :name
       end
-    end
 
-    def after_teardown
-      @db_connection = ActiveRecord::Base.establish_connection( :adapter => "sqlite3", :database => "testdb.sqlite3")
-      ActiveRecord::Migration.class_eval do
-        @connection = @db_connection
-        drop_table :users
-        drop_table :aliases
+      create_table :aliases do |t|
+        t.integer :user_id
+        t.string :aka
       end
     end
+  end
 
-    def test_basic_creation
-      a_user = User.new :name => "Bob"
-      assert a_user.new_record?
-      a_user.save!
-      assert User.connected?
-      assert a_user.persisted?
-      assert a_user.id == 1
+  def after_teardown
+    ActiveRecord::Migration.class_eval do
+      @connection = @db_connection
+      drop_table :users
+      drop_table :aliases
     end
+  end
 
-    def test_alias_collection_query_method
-      a_user = User.new :name => "Bob"
-      a_user.save!
-      a_user = User.find(1)
-      assert User.connected?
-      assert a_user.id = 1
-
-      an_alias = Alias.new :user_id => a_user.id, :aka => "the Blob"
-      assert an_alias.new_record?
-      an_alias.save!
-      assert an_alias.persisted?
-      an_alias.destroy
-      assert an_alias.destroyed?
-    end
+  def test_basic_creation
+    a_user = User.new :name => "Bob"
+    assert a_user.new_record?
+    a_user.save!
+    assert User.connected?
+    assert a_user.persisted?
+    assert a_user.id == 1
+  end
 
-  else
-    def test_truth
-      assert true # jruby freaks out if there are no tests defined in the test class
-    end
-    puts yellow('SKIPPED! skipped until ruby 1.8.6 compatibilites ironed out')
+  def test_alias_collection_query_method
+    a_user = User.new :name => "Bob"
+    a_user.save!
+    a_user = User.find(1)
+    assert User.connected?
+    assert a_user.id = 1
+
+    an_alias = Alias.new :user_id => a_user.id, :aka => "the Blob"
+    assert an_alias.new_record?
+    an_alias.save!
+    assert an_alias.persisted?
+    an_alias.destroy
+    assert an_alias.destroyed?
   end
 end

data/test/multiverse/suites/agent_only/encoding_handling_test.rb

@@ -0,0 +1,128 @@
+# 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.
+
+if RUBY_VERSION >= '1.9'
+
+class CollectorExceptionHandlingTest < MiniTest::Unit::TestCase
+  include MultiverseHelpers
+
+  setup_and_teardown_agent
+
+  # We're hitting a Rubinius bug when running this test there:
+  # https://github.com/rubinius/rubinius/issues/2899
+  unless NewRelic::LanguageSupport.rubinius?
+    def test_handles_mis_encoded_database_queries
+      with_config(:'transaction_tracer.transaction_threshold' => 0.0,
+        :'transaction_tracer.record_sql' => :raw) do
+        in_transaction do
+          agent.transaction_sampler.notice_sql(bad_string, nil, 42)
+        end
+        assert_endpoint_received_string('transaction_sample_data', normalized_bad_string)
+      end
+    end
+  end
+
+  def test_handles_mis_encoded_request_params
+    with_config(:'capture_params' => true,
+      :'transaction_tracer.transaction_threshold' => 0.0) do
+      options = { :filtered_params => { bad_string => bad_string }}
+      in_transaction(options) do
+        # nothin
+      end
+    end
+    assert_endpoint_received_string('transaction_sample_data', normalized_bad_string)
+  end
+
+  def test_handles_mis_encoded_custom_params
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      in_transaction do
+        NewRelic::Agent.add_custom_parameters(:foo => bad_string)
+      end
+    end
+    assert_endpoint_received_string('transaction_sample_data', normalized_bad_string)
+  end
+
+  def test_handles_mis_encoded_custom_params_on_analytics_events
+    in_transaction(:type => :controller) do
+      NewRelic::Agent.add_custom_parameters(:foo => bad_string)
+    end
+    assert_endpoint_received_string('analytic_event_data', normalized_bad_string)
+  end
+
+  def test_handles_mis_encoded_custom_params_on_errors
+    NewRelic::Agent.notice_error('bad news', :custom_params => {'foo' => bad_string})
+    assert_endpoint_received_string('error_data', normalized_bad_string)
+  end
+
+  def test_handles_mis_encoded_exception_message
+    NewRelic::Agent.notice_error(bad_string)
+    assert_endpoint_received_string('error_data', normalized_bad_string)
+  end
+
+  def test_handles_mis_encoded_metric_names
+    NewRelic::Agent.record_metric(bad_string, 42)
+    assert_endpoint_received_string('metric_data', normalized_bad_string)
+  end
+
+  def test_handles_mis_encoded_transaction_names
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      in_transaction do
+        NewRelic::Agent.set_transaction_name(bad_string)
+      end
+    end
+    expected_transaction_name = "other/#{normalized_bad_string}"
+    assert_endpoint_received_string('transaction_sample_data', expected_transaction_name)
+  end
+
+  def test_handles_mis_encoded_strings_in_environment_report
+    $collector.reset
+    ::NewRelic::EnvironmentReport.report_on('Dummy') do
+      bad_string
+    end
+    agent.instance_variable_set(:@environment_report, agent.environment_for_connect)
+    agent.connect_to_server
+    assert_endpoint_received_string('connect', normalized_bad_string)
+  end
+
+  def assert_endpoint_received_string(endpoint, string)
+    agent.send(:transmit_data)
+    requests = $collector.calls_for(endpoint)
+    assert_equal(1, requests.size)
+    request = requests.first
+    request.decode! if request.respond_to?(:decode!)
+    assert_contains_string(request, string)
+  end
+
+  def assert_contains_string(request, string)
+    object_graph = request.body
+    object_graph = request.samples if request.respond_to?(:samples)
+    assert object_graph_contains_string?(request.body, string), "Did not find desired string in #{request.body.inspect}"
+  end
+
+  def object_graph_contains_string?(object_graph, string)
+    case object_graph
+    when String
+      string == object_graph
+    when Array
+      object_graph.any? { |x| object_graph_contains_string?(x, string) }
+    when Hash
+      (
+        object_graph_contains_string?(object_graph.keys, string) ||
+        object_graph_contains_string?(object_graph.values, string)
+      )
+    else
+      false
+    end
+  end
+
+  def bad_string
+    (0..250).to_a.pack("C*").force_encoding('UTF-8')
+  end
+
+  def normalized_bad_string
+    bad_string.force_encoding('ISO-8859-1').encode('UTF-8')
+  end
+end
+
+end

data/test/multiverse/suites/agent_only/marshaling_test.rb

@@ -33,15 +33,13 @@ class MarshalingTest < MiniTest::Unit::TestCase
     agent.service.connect
     agent.send(:harvest_and_send_transaction_traces)
 
-    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-    else
-      marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
-    end
-
-    assert_equal('666', $collector.calls_for('transaction_sample_data')[0].run_id)
-    assert_equal(expected_sample.to_collector_array(marshaller.default_encoder),
-                 $collector.calls_for('transaction_sample_data')[0][1][0])
+    marshaller = agent.service.marshaller
+
+    transaction_sample_data_post = $collector.calls_for('transaction_sample_data')[0]
+    assert_equal('666', transaction_sample_data_post.run_id)
+    encoder = NewRelic::Agent::NewRelicService::Encoders::Identity
+    assert_equal(expected_sample.to_collector_array(encoder),
+                 transaction_sample_data_post[1][0])
   end
 
   def test_metric_data_marshalling

data/test/multiverse/suites/agent_only/script/loading.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# 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.
+
+ENV["NEW_RELIC_LOG_FILE_PATH"] = "STDOUT"
+
+require 'newrelic_rpm'
+
+# Force all named items to re-enable
+enable_everyone = {}
+DependencyDetection.items.each do |item|
+  if item.name
+    enable_everyone["disable_#{item.name}".to_sym] = false
+  end
+end
+NewRelic::Agent.config.apply_config(enable_everyone)
+
+# Run dependency detection again!
+DependencyDetection.detect!

data/test/multiverse/suites/agent_only/start_up_test.rb

@@ -23,4 +23,11 @@ class StartUpTest < MiniTest::Unit::TestCase
 
     assert_equal '', output.chomp
   end
+
+  def test_instrumentation_loads_clean_even_without_dependencies
+    output = `bundle exec ruby script/loading.rb`
+
+    problems = output.scan(/ERROR : .*/)
+    assert_empty problems
+  end
 end

data/test/multiverse/suites/bare/Envfile

@@ -0,0 +1,3 @@
+gemfile <<-RB
+  gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')
+RB

data/test/multiverse/suites/bare/standalone_instrumentation_test.rb

@@ -0,0 +1,43 @@
+# 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.
+
+# This test is based on the example code at:
+# https://docs.newrelic.com/docs/ruby/ruby-custom-metric-collection#example_class
+# 
+# See https://newrelic.atlassian.net/browse/RUBY-1116 for details on how this
+# was broken previously.
+
+require 'new_relic/agent/method_tracer' 
+
+class StandaloneInstrumentationTest < MiniTest::Unit::TestCase
+  class InstrumentedClass
+    def instance_method(*args)
+      args
+    end
+
+    def self.class_method(*args)
+      args
+    end
+
+    include NewRelic::Agent::MethodTracer
+    add_method_tracer :instance_method
+
+    class << self
+      include ::NewRelic::Agent::MethodTracer
+      add_method_tracer :class_method
+    end
+  end
+
+  def test_instance_method_tracers_should_not_cause_errors
+    args = [1, 2, 3]
+    result = InstrumentedClass.new.instance_method(*args)
+    assert_equal(args, result)
+  end
+
+  def test_class_method_tracer_should_not_cause_errors
+    args = [1, 2, 3]
+    result = InstrumentedClass.class_method(*args)
+    assert_equal(args, result)
+  end
+end

data/test/multiverse/suites/rails/Envfile

@@ -5,8 +5,6 @@ if RUBY_VERSION >= '1.9.3'
   RB
 end
 
-omit_mocha!
-
 gemfile <<-RB
   gem 'rails', '~>3.2.16'
   gem 'haml', '4.0.2'   # Getting load issues with haml 4.0.3

data/test/multiverse/suites/rails/app/views/views/_a_partial.html.erb

@@ -1 +1,2 @@
+<%- advance_time(@delay) if @delay %>
 This is a partial

data/test/multiverse/suites/rails/app/views/views/index.html.erb

@@ -1,4 +1,4 @@
-
+<%- advance_time(@delay) if @delay %>
 <%- 3.times do |i| %>
 <%= render "a_partial" %>
 <%- end%>

data/test/multiverse/suites/rails/error_tracing_test.rb

@@ -218,7 +218,7 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
     end
 
     def test_captured_errors_should_not_include_custom_params_if_config_says_no
-      with_config(:'capture_attributes.traces' => false) do
+      with_config(:'error_collector.capture_attributes' => false) do
         get '/error/error_with_custom_params'
       end
       assert_error_reported_once('bad things')

data/test/multiverse/suites/rails/request_statistics_test.rb

@@ -79,15 +79,20 @@ class RequestStatsTest < ActionController::TestCase
       assert_kind_of Array, post.body
       assert_kind_of Array, post.body.first
 
-      sample = post.body.first.first
+      sample = post.body.first[0]
       assert_kind_of Hash, sample
 
       assert_equal 'Controller/request_stats/stats_action_with_custom_params', sample['name']
       assert_encoding 'utf-8', sample['name']
       assert_equal 'Transaction', sample['type']
-      assert_equal 'blue', sample['color']
-      assert_equal 'bar', sample['1']
-      assert_false sample.has_key?('bad')
+      ['blue', 'bar', 'bad'].each do |key|
+        assert_not_includes(sample, key)
+      end
+
+      custom_params = post.body.first[1]
+      assert_equal 'blue', custom_params['color']
+      assert_equal 'bar', custom_params['1']
+      assert_false custom_params.has_key?('bad')
     end
   end
 

data/test/multiverse/suites/rails/view_instrumentation_test.rb

@@ -10,10 +10,17 @@ ActionController::Base.view_paths = ['app/views']
 
 class ViewsController < ApplicationController
   include Rails.application.routes.url_helpers
+
   def template_render_with_3_partial_renders
     render 'index'
   end
 
+  def render_with_delays
+    freeze_time
+    @delay = 1
+    render 'index'
+  end
+
   def deep_partial_render
     render 'deep_partial'
   end
@@ -63,10 +70,11 @@ class ViewsController < ApplicationController
   # proc rendering isn't available in rails 3 but you can do nonsense like this
   # and assign an enumerable object to the response body.
   def proc_render
-    streamer = Class.new
-    def each
-      10_000.times do |i|
-        yield "This is line #{i}\n"
+    streamer = Class.new do
+      def each
+        10_000.times do |i|
+          yield "This is line #{i}\n"
+        end
       end
     end
     self.response_body = streamer.new
@@ -77,12 +85,10 @@ class ViewsController < ApplicationController
   end
 end
 
-class ViewControllerTest < ActionController::TestCase
-  tests ViewsController
-
+class ViewInstrumentationTest < ActionDispatch::IntegrationTest
   include MultiverseHelpers
+
   setup_and_teardown_agent do
-    @controller = ViewsController.new
     # ActiveSupport testing keeps blowing away my subscribers on
     # teardown for some reason.  Have to keep putting it back.
     if Rails::VERSION::MAJOR.to_i == 4
@@ -92,128 +98,127 @@ class ViewControllerTest < ActionController::TestCase
         .subscribe(/^process_action.action_controller$/)
     end
   end
-end
 
-# SANITY TESTS - Make sure nothing raises errors,
-# unless it's supposed to
-class SanityTest < ViewControllerTest
-
-  # assert we can call any of these renders with no errors
-  # (except the one that does raise an error)
-  (ViewsController.action_methods - ["raise_render"]).each do |method|
-    test "should not raise errors on GET to #{method.inspect}" do
-      get method.dup
+  (ViewsController.action_methods - ['raise_render']).each do |method|
+    define_method("test_sanity_#{method}") do
+      get "views/#{method}"
+      assert_equal 200, status
     end
 
-    test "should not raise errors on POST to #{method.inspect}" do
-      post method.dup
+    def test_should_allow_uncaught_exception_to_propagate
+      get "views/raise_render"
+      assert_equal 500, status
     end
-  end
 
-  test "should allow an uncaught exception to propogate" do
-    assert_raises RuntimeError do
-      get :raise_render
+    def test_should_count_all_the_template_and_partial_segments
+      get 'views/template_render_with_3_partial_renders'
+      sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+      assert_equal 5, sample.count_segments, "should be a node for the controller action, the template, and 3 partials (5)"
     end
-  end
-end
 
-# A controller action that renders 1 template and the same partial 3 times
-class NormalishRenderTest < ViewControllerTest
-  test "should count all the template and partial segments" do
-    get :template_render_with_3_partial_renders
-    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-    assert_equal 5, sample.count_segments, "should be a node for the controller action, the template, and 3 partials (5)"
-  end
+    def test_should_have_3_segments_with_the_correct_metric_name
+      get 'views/template_render_with_3_partial_renders'
+      sample = NewRelic::Agent.agent.transaction_sampler.last_sample
 
-  test "should have 3 segments with the metric name 'View/views/_a_partial.html.erb/Partial'" do
-    get :template_render_with_3_partial_renders
-    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+      partial_segments = sample.root_segment.called_segments.first.called_segments.first.called_segments
+      assert_equal 3, partial_segments.size, "sanity check"
 
-    partial_segments = sample.root_segment.called_segments.first.called_segments.first.called_segments
-    assert_equal 3, partial_segments.size, "sanity check"
+      assert_equal ['View/views/_a_partial.html.erb/Partial'], partial_segments.map(&:metric_name).uniq
+    end
 
-    assert_equal ['View/views/_a_partial.html.erb/Partial'], partial_segments.map(&:metric_name).uniq
-  end
-end
+    # it doesn't seem worth it to get consistent behavior here.
+    if Rails::VERSION::MAJOR.to_i == 3 && Rails::VERSION::MINOR.to_i == 0
+      def test_should_not_instrument_rendering_of_text
+        get 'views/text_render'
+        sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+        assert_equal [], sample.root_segment.called_segments.first.called_segments
+      end
+    else
+      def test_should_create_a_metric_for_the_rendered_text
+        get 'views/text_render'
+        sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+        text_segment = sample.root_segment.called_segments.first.called_segments.first
+        assert_equal 'View/text template/Rendering', text_segment.metric_name
+      end
+    end
 
-class TextRenderTest < ViewControllerTest
-  # it doesn't seem worth it to get consistent behavior here.
-  if Rails::VERSION::MAJOR.to_i == 3 && Rails::VERSION::MINOR.to_i == 0
-    test "should not instrument rendering of text" do
-      get :text_render
+    def test_should_create_a_metric_for_the_rendered_inline_template
+      get 'views/inline_render'
       sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-      assert_equal [], sample.root_segment.called_segments.first.called_segments
+      text_segment = sample.root_segment.called_segments.first.called_segments.first
+      assert_equal 'View/inline template/Rendering', text_segment.metric_name
     end
-  else
-    test "should create a metric for the rendered text" do
-      get :text_render
+
+    def test_should_create_a_metric_for_the_rendered_haml_template
+      get 'views/haml_render'
       sample = NewRelic::Agent.agent.transaction_sampler.last_sample
       text_segment = sample.root_segment.called_segments.first.called_segments.first
-      assert_equal 'View/text template/Rendering', text_segment.metric_name
+      assert_equal 'View/views/haml_view.html.haml/Rendering', text_segment.metric_name
     end
-  end
-end
-
-class InlineTemplateRenderTest < ViewControllerTest
-  test "should create a metric for the rendered inline template" do
-    get :inline_render
-    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-    text_segment = sample.root_segment.called_segments.first.called_segments.first
-    assert_equal 'View/inline template/Rendering', text_segment.metric_name
-  end
-end
 
-class HamlRenderTest < ViewControllerTest
-  test "should create a metric for the rendered haml template" do
-    get :haml_render
-    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-    text_segment = sample.root_segment.called_segments.first.called_segments.first
-    assert_equal 'View/views/haml_view.html.haml/Rendering', text_segment.metric_name
-  end
-end
+    def test_should_create_a_proper_metric_when_the_template_is_unknown
+      get 'views/no_template'
+      sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+      text_segment = sample.root_segment.called_segments.first.called_segments.first
 
-class MissingTemplateTest < ViewControllerTest
-  test "should create an proper metric when the template is unknown" do
-    get :no_template
-    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-    text_segment = sample.root_segment.called_segments.first.called_segments.first
+      # Different versions have significant difference in handling, but we're
+      # happy enough with what each of them does in the unknown case
+      if Rails::VERSION::MAJOR.to_i == 3 && Rails::VERSION::MINOR.to_i == 0
+        assert_nil text_segment
+      elsif Rails::VERSION::MAJOR.to_i == 3
+        assert_equal 'View/collection/Partial', text_segment.metric_name
+      else
+        assert_equal 'View/(unknown)/Partial', text_segment.metric_name
+      end
+    end
 
-    # Different versions have significant difference in handling, but we're
-    # happy enough with what each of them does in the unknown case
-    if Rails::VERSION::MAJOR.to_i == 3 && Rails::VERSION::MINOR.to_i == 0
-      assert_nil text_segment
-    elsif Rails::VERSION::MAJOR.to_i == 3
-      assert_equal 'View/collection/Partial', text_segment.metric_name
-    else
-      assert_equal 'View/(unknown)/Partial', text_segment.metric_name
+    def test_should_create_a_proper_metric_when_we_render_a_collection
+      get 'views/collection_render'
+      sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+      text_segment = sample.root_segment.called_segments.first.called_segments.first
+      assert_equal "View/foos/_foo.html.haml/Partial", text_segment.metric_name
     end
-  end
-end
 
-class CollectionTemplateTest < ViewControllerTest
-  test "should create a proper metric when we render a collection" do
-    get :collection_render
-    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-    text_segment = sample.root_segment.called_segments.first.called_segments.first
-    assert_equal "View/foos/_foo.html.haml/Partial", text_segment.metric_name
-  end
-end
+    [:js_render, :xml_render, :proc_render, :json_render ].each do |action|
+      define_method("test_should_not_instrument_rendering_of_#{action}") do
+        get "views/#{action}"
+        sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+        assert_equal [], sample.root_segment.called_segments.first.called_segments
+      end
+    end
 
-class UninstrumentedRendersTest < ViewControllerTest
-  [:js_render, :xml_render, :proc_render, :json_render ].each do |action|
-    test "should not instrument rendering of #{action.inspect}" do
-      get action
+    def test_should_create_a_metric_for_rendered_file_that_does_not_include_the_filename_so_it_doesnt_metric_explode
+      get 'views/file_render'
       sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-      assert_equal [], sample.root_segment.called_segments.first.called_segments
+      text_segment = sample.root_segment.called_segments.first.called_segments.first
+      assert_equal 'View/file/Rendering', text_segment.metric_name
     end
-  end
-end
 
-class FileRenderTest < ViewControllerTest
-  test "should create a metric for rendered file that does not include the filename so it doesn't metric explode" do
-    get :file_render
-    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
-    text_segment = sample.root_segment.called_segments.first.called_segments.first
-    assert_equal 'View/file/Rendering', text_segment.metric_name
+    def test_exclusive_time_for_template_render_metrics_should_not_include_partial_rendering_time
+      get 'views/render_with_delays'
+
+      expected_stats_partial = {
+        :call_count           => 3,
+        :total_call_time      => 3.0,
+        :total_exclusive_time => 3.0
+      }
+
+      expected_stats_template = {
+        :call_count           => 1,
+        :total_call_time      => 4.0,
+        :total_exclusive_time => 1.0  # top-level template takes 1s itself
+      }
+
+      scope = 'Controller/views/render_with_delays'
+      partial_metric  = 'View/views/_a_partial.html.erb/Partial'
+      template_metric = 'View/views/index.html.erb/Rendering'
+
+      assert_metrics_recorded(
+         partial_metric           => expected_stats_partial,
+         template_metric          => expected_stats_template,
+         [partial_metric, scope]  => expected_stats_partial,
+         [template_metric, scope] => expected_stats_template
+      )
+    end
   end
 end