newrelic_rpm 3.18.1.330 → 4.0.0.332

data/test/new_relic/agent/error_collector_test.rb

@@ -48,17 +48,6 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     assert_equal 1, events.length
   end
 
-  def test_drops_deprecated_options
-    expects_logging(:warn, any_parameters)
-    error = @error_collector.create_noticed_error(StandardError.new("message"),
-                                  :referer => "lalalalala",
-                                  :request => stub('request'),
-                                  :request_params => {:x => 'y'})
-
-
-    assert_empty error.attributes_from_notice_error
-  end
-
   def test_exclude
     @error_collector.ignore(["IOError"])
 
@@ -124,9 +113,15 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
   end
 
   def test_increments_count_on_errors
-    expects_error_count_increase(1) do
-      @error_collector.notice_error(StandardError.new("Boo"))
-    end
+    @error_collector.notice_error(StandardError.new("Boo"))
+    assert_metrics_recorded(
+      'Errors/all' => { :call_count => 1}
+    )
+
+    @error_collector.notice_error(StandardError.new("Boo"))
+    assert_metrics_recorded(
+      'Errors/all' => { :call_count => 2}
+    )
   end
 
   def test_increment_error_count_record_summary_and_web_txn_metric
@@ -250,33 +245,15 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
   end
 
   def test_extract_stack_trace
-    exception = mock('exception', :cause => nil,
-                                  :original_exception => nil,
-                                  :backtrace => nil)
-
-    assert_equal('<no stack trace>', @error_collector.extract_stack_trace(exception))
+    assert_equal('<no stack trace>', @error_collector.extract_stack_trace(Exception.new))
   end
 
-  def test_extract_stack_trace_uses_cause_first
-    nested_exception = mock('exception', :backtrace => "Foo STACK")
-    exception = mock('exception', :cause => nested_exception)
-
-    assert_equal('Foo STACK', @error_collector.extract_stack_trace(exception))
-  end
-
-  def test_extract_stack_trace_uses_original_exception_second
-    nested_exception = mock('exception', :backtrace => "Bar STACK")
-    exception = mock('exception', :cause => nil, :original_exception => nested_exception)
-
-    assert_equal('Bar STACK', @error_collector.extract_stack_trace(exception))
-  end
-
-  def test_extract_stack_trace_uses_backtrace_last
-    exception = mock('exception', :cause => nil,
-                                  :original_exception => nil,
-                                  :backtrace => "Baz STACK")
-
-    assert_equal('Baz STACK', @error_collector.extract_stack_trace(exception))
+  if defined?(Rails) && Rails::VERSION::MAJOR < 5
+    def test_extract_stack_trace_from_original_exception
+      orig = mock('original', :backtrace => "STACK STACK STACK")
+      exception = mock('exception', :original_exception => orig)
+      assert_equal('STACK STACK STACK', @error_collector.extract_stack_trace(exception))
+    end
   end
 
   def test_skip_notice_error_is_true_if_the_error_collector_is_disabled
@@ -410,16 +387,6 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
 
   private
 
-  def expects_error_count_increase(increase)
-    count = get_error_stats
-    yield
-    assert_equal increase, get_error_stats - count
-  end
-
-  def get_error_stats
-    NewRelic::Agent.get_stats("Errors/all").call_count
-  end
-
   def wrapped_filter_proc
     Proc.new do |e|
       if e.is_a? IOError

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

@@ -62,11 +62,5 @@ module NewRelic::Agent::Instrumentation
       assert_equal "other", operation
       assert_nil collection
     end
-
-    def test_rollup_metrics_for_is_deprecated
-      NewRelic::Agent::Deprecator.expects(:deprecate)
-      result = ActiveRecordHelper.rollup_metrics_for("boo")
-      assert_equal ["Datastore/allOther", "Datastore/all"], result
-    end
   end
 end

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

@@ -4,7 +4,7 @@
 
 MIN_RAILS_VERSION = 4
 
-if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i >= MIN_RAILS_VERSION && !NewRelic::LanguageSupport.using_engine?('jruby')
+if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i >= MIN_RAILS_VERSION && !NewRelic::LanguageSupport.jruby?
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 require 'new_relic/agent/instrumentation/active_record_subscriber'

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

@@ -7,108 +7,106 @@ require 'new_relic/agent/instrumentation/mongodb_command_subscriber'
 
 class NewRelic::Agent::Instrumentation::MongodbCommandSubscriberTest < Minitest::Test
 
-  if RUBY_VERSION > "1.9.3"
-    def setup
-      freeze_time
-      @started_event = mock('started event')
-      @started_event.stubs(:operation_id).returns(1)
-      @started_event.stubs(:command_name).returns('find')
-      @started_event.stubs(:database_name).returns('mongodb-test')
-      @started_event.stubs(:command).returns({ 'find' => 'users', 'filter' => { 'name' => 'test' }})
-      address = stub('address', :host => "127.0.0.1", :port => 27017)
-      @started_event.stubs(:address).returns(address)
-
-      @succeeded_event = mock('succeeded event')
-      @succeeded_event.stubs(:operation_id).returns(1)
-      @succeeded_event.stubs(:duration).returns(2)
-
-      @subscriber = NewRelic::Agent::Instrumentation::MongodbCommandSubscriber.new
-
-      NewRelic::Agent::Hostname.stubs(:get).returns("nerd-server")
-      @stats_engine = NewRelic::Agent.instance.stats_engine
-      @stats_engine.clear_stats
-    end
-
-    def test_records_metrics_for_simple_find
-      in_transaction { simulate_query }
-
-      metric_name = 'Datastore/statement/MongoDB/users/find'
-      assert_metrics_recorded(
-        metric_name => { :call_count => 1, :total_call_time => 2.0 }
-      )
-    end
-
-    def test_records_scoped_metrics
-      in_transaction('test_txn') { simulate_query }
-
-      metric_name = 'Datastore/statement/MongoDB/users/find'
-      assert_metrics_recorded(
-        [ metric_name, 'test_txn' ] => { :call_count => 1, :total_call_time => 2 }
-      )
-    end
-
-    def test_records_nothing_if_tracing_disabled
-      NewRelic::Agent.disable_all_tracing { simulate_query }
-      metric_name = 'Datastore/statement/MongoDB/users/find'
-      assert_metrics_not_recorded([ metric_name ])
-    end
-
-    def test_records_rollup_metrics
-      in_web_transaction { simulate_query }
-
-      assert_metrics_recorded(
-        'Datastore/operation/MongoDB/find' => { :call_count => 1, :total_call_time => 2 },
-        'Datastore/allWeb' => { :call_count => 1, :total_call_time => 2 },
-        'Datastore/all' => { :call_count => 1, :total_call_time => 2 }
-      )
-    end
-
-    def test_should_not_raise_due_to_an_exception_during_instrumentation_callback
-      @subscriber.stubs(:metrics).raises(StandardError)
-      in_transaction { simulate_query }
-    end
-
-    def test_records_instance_metrics_for_tcp_connection
-      in_transaction { simulate_query }
-      assert_metrics_recorded('Datastore/instance/MongoDB/nerd-server/27017')
-    end
-
-    def test_records_instance_metrics_for_unix_domain_socket
-      address = stub('address', :host => "/tmp/mongodb-27017.sock", :port => nil)
-      @started_event.stubs(:address).returns(address)
-      in_transaction { simulate_query }
-      assert_metrics_recorded('Datastore/instance/MongoDB/nerd-server//tmp/mongodb-27017.sock')
-    end
-
-    def test_records_unknown_unknown_metric_when_error_gathering_instance_data
-      @started_event.stubs(:address).returns(nil)
-      in_transaction { simulate_query }
-      assert_metrics_recorded('Datastore/instance/MongoDB/unknown/unknown')
-    end
-
-    def test_records_tt_segment_parameters_for_datastore_instance
-      in_transaction { simulate_query }
-
-      tt = last_transaction_trace
-
-      node = find_node_with_name_matching tt, /^Datastore\//
-
-      assert_equal(NewRelic::Agent::Hostname.get, node[:host])
-      assert_equal('27017', node[:port_path_or_id])
-      assert_equal('mongodb-test', node[:database_name])
-    end
-
-    def test_does_not_record_unknown_unknown_metric_when_data_empty
-      address = stub('address', :host => "", :port => "")
-      @started_event.stubs(:address).returns(address)
-      in_transaction { simulate_query }
-      assert_metrics_not_recorded('Datastore/instance/MongoDB/unknown/unknown')
-    end
-
-    def simulate_query
-      @subscriber.started(@started_event)
-      advance_time @succeeded_event.duration
-      @subscriber.succeeded(@succeeded_event)
-    end
+  def setup
+    freeze_time
+    @started_event = mock('started event')
+    @started_event.stubs(:operation_id).returns(1)
+    @started_event.stubs(:command_name).returns('find')
+    @started_event.stubs(:database_name).returns('mongodb-test')
+    @started_event.stubs(:command).returns({ 'find' => 'users', 'filter' => { 'name' => 'test' }})
+    address = stub('address', :host => "127.0.0.1", :port => 27017)
+    @started_event.stubs(:address).returns(address)
+
+    @succeeded_event = mock('succeeded event')
+    @succeeded_event.stubs(:operation_id).returns(1)
+    @succeeded_event.stubs(:duration).returns(2)
+
+    @subscriber = NewRelic::Agent::Instrumentation::MongodbCommandSubscriber.new
+
+    NewRelic::Agent::Hostname.stubs(:get).returns("nerd-server")
+    @stats_engine = NewRelic::Agent.instance.stats_engine
+    @stats_engine.clear_stats
+  end
+
+  def test_records_metrics_for_simple_find
+    in_transaction { simulate_query }
+
+    metric_name = 'Datastore/statement/MongoDB/users/find'
+    assert_metrics_recorded(
+      metric_name => { :call_count => 1, :total_call_time => 2.0 }
+    )
+  end
+
+  def test_records_scoped_metrics
+    in_transaction('test_txn') { simulate_query }
+
+    metric_name = 'Datastore/statement/MongoDB/users/find'
+    assert_metrics_recorded(
+      [ metric_name, 'test_txn' ] => { :call_count => 1, :total_call_time => 2 }
+    )
+  end
+
+  def test_records_nothing_if_tracing_disabled
+    NewRelic::Agent.disable_all_tracing { simulate_query }
+    metric_name = 'Datastore/statement/MongoDB/users/find'
+    assert_metrics_not_recorded([ metric_name ])
+  end
+
+  def test_records_rollup_metrics
+    in_web_transaction { simulate_query }
+
+    assert_metrics_recorded(
+      'Datastore/operation/MongoDB/find' => { :call_count => 1, :total_call_time => 2 },
+      'Datastore/allWeb' => { :call_count => 1, :total_call_time => 2 },
+      'Datastore/all' => { :call_count => 1, :total_call_time => 2 }
+    )
+  end
+
+  def test_should_not_raise_due_to_an_exception_during_instrumentation_callback
+    @subscriber.stubs(:metrics).raises(StandardError)
+    in_transaction { simulate_query }
+  end
+
+  def test_records_instance_metrics_for_tcp_connection
+    in_transaction { simulate_query }
+    assert_metrics_recorded('Datastore/instance/MongoDB/nerd-server/27017')
+  end
+
+  def test_records_instance_metrics_for_unix_domain_socket
+    address = stub('address', :host => "/tmp/mongodb-27017.sock", :port => nil)
+    @started_event.stubs(:address).returns(address)
+    in_transaction { simulate_query }
+    assert_metrics_recorded('Datastore/instance/MongoDB/nerd-server//tmp/mongodb-27017.sock')
+  end
+
+  def test_records_unknown_unknown_metric_when_error_gathering_instance_data
+    @started_event.stubs(:address).returns(nil)
+    in_transaction { simulate_query }
+    assert_metrics_recorded('Datastore/instance/MongoDB/unknown/unknown')
+  end
+
+  def test_records_tt_segment_parameters_for_datastore_instance
+    in_transaction { simulate_query }
+
+    tt = last_transaction_trace
+
+    node = find_node_with_name_matching tt, /^Datastore\//
+
+    assert_equal(NewRelic::Agent::Hostname.get, node[:host])
+    assert_equal('27017', node[:port_path_or_id])
+    assert_equal('mongodb-test', node[:database_name])
+  end
+
+  def test_does_not_record_unknown_unknown_metric_when_data_empty
+    address = stub('address', :host => "", :port => "")
+    @started_event.stubs(:address).returns(address)
+    in_transaction { simulate_query }
+    assert_metrics_not_recorded('Datastore/instance/MongoDB/unknown/unknown')
+  end
+
+  def simulate_query
+    @subscriber.started(@started_event)
+    advance_time @succeeded_event.duration
+    @subscriber.succeeded(@succeeded_event)
   end
 end

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

@@ -13,33 +13,30 @@ class MinimalRackApp
   def call(env)
     @return_value
   end
-
-  include NewRelic::Agent::Instrumentation::Rack
 end
 
 class NewRelic::Agent::Instrumentation::RackTest < Minitest::Test
+
+  def generate_minimal_rack_app mock_response
+    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(MinimalRackApp)
+    generator.new(mock_response)
+  end
+
   def test_basic_rack_app
     # should return what we send in, even when instrumented
-    x = MinimalRackApp.new([200, {}, ["whee"]])
+    x = generate_minimal_rack_app([200, {}, ["whee"]])
     assert_equal [200, {}, ["whee"]], x.call({})
-    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
+    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp/call'])
   end
 
   def test_basic_rack_app_404
-    x = MinimalRackApp.new([404, {}, ["whee"]])
-    assert_equal [404, {}, ["whee"]], x.call({})
-    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
-  end
-
-  def test_basic_rack_app_ignores_404
-    NewRelic::Agent::Transaction.expects(:abort_transaction!)
-    x = MinimalRackApp.new([404, {}, ["whee"]])
+    x = generate_minimal_rack_app([404, {}, ["whee"]])
     assert_equal [404, {}, ["whee"]], x.call({})
-    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
+    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp/call'])
   end
 
   def test_does_not_double_instrument_middlewares
-    x = MinimalRackApp.new([200, {}, ["whee"]])
+    x = generate_minimal_rack_app([200, {}, ["whee"]])
     wrapped_x = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(x)
 
     assert_same(x, wrapped_x)

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

@@ -140,16 +140,6 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Minitest::Test
     assert_equal(10, attributes_for(sample, :agent)['request.parameters.level'])
   end
 
-  def test_abort_transaction
-    perform_action_with_newrelic_trace(:name => 'hello', :force => true) do
-      self.class.inspect
-      NewRelic::Agent.abort_transaction!
-    end
-    # We record the controller metric still, but abort any transaction recording.
-    assert_metrics_recorded(['Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello'])
-    assert_nil(@agent.transaction_sampler.last_sample)
-  end
-
   def test_perform_action_with_newrelic_trace_saves_params
     account = 'Redrocks'
     with_config(:capture_params => true) do

data/test/new_relic/agent/javascript_instrumentor_test.rb

@@ -144,7 +144,7 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
 
   def test_browser_timing_header_safe_when_json_dump_fails
     in_transaction do
-      NewRelic::JSONWrapper.stubs(:dump).raises("Serialize? Hahahaha")
+      ::JSON.stubs(:dump).raises("Serialize? Hahahaha")
       assert_equal "", instrumentor.browser_timing_header
     end
   end
@@ -323,7 +323,7 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
 
   def unpack_to_object(text)
     unpacked_atts = instrumentor.obfuscator.deobfuscate(text)
-    NewRelic::JSONWrapper.load(unpacked_atts)
+    ::JSON.load(unpacked_atts)
   end
 
   def formatted_for_matching(value)

data/test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb

@@ -64,16 +64,6 @@ module NewRelic
               check_for_illegal_keys!(:rainbow_dash, test_keys)
             end
 
-            def test_check_for_illegal_keys_deprecated
-              log = with_array_logger do
-                check_for_illegal_keys!(:rarity, :force => true)
-              end.array
-
-              assert_equal(1, log.size)
-
-              assert_match(/Deprecated options when adding method tracer to rarity: force/, log[0])
-            end
-
             def test_traced_method_exists_positive
               self.expects(:_traced_method_name)
               self.expects(:method_defined?).returns(true)

data/test/new_relic/agent/method_tracer_test.rb

@@ -120,9 +120,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
       end
     end
 
-    stats = @stats_engine.get_stats(metric)
-    check_time 0.05, stats.total_call_time
-    assert_equal 1, stats.call_count
+    assert_metrics_recorded metric => {:call_count => 1, :total_call_time => 0.05}
   end
 
   def test_trace_execution_scoped_with_no_metrics_skips_out
@@ -142,20 +140,6 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     end
   end
 
-  def test_basic__original_api
-    metric = "hello"
-    in_transaction do |txn|
-      self.class.trace_method_execution(metric, true, true, true) do
-        advance_time(0.05)
-      end
-      assert_equal metric,  @scope_listener.scopes.last
-    end
-
-    stats = @stats_engine.get_stats(metric)
-    check_time 0.05, stats.total_call_time
-    assert_equal 1, stats.call_count
-  end
-
   METRIC = "metric"
   def test_add_method_tracer
     @metric_name = METRIC
@@ -172,10 +156,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
       # ignore 'no tracer' errors from remove method tracer
     end
 
-
-    stats = @stats_engine.get_stats(METRIC)
-    check_time 0.05, stats.total_call_time
-    assert_equal 1, stats.call_count
+    assert_metrics_recorded METRIC => {:call_count => 1, :total_call_time => 0.05}
   end
 
   def test_add_method_tracer__default
@@ -185,16 +166,17 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
       simple_method
     end
 
-    stats = @stats_engine.get_stats("Custom/#{self.class.name}/simple_method")
-    assert stats.call_count == 1
+    metric = "Custom/#{self.class.name}/simple_method"
+    assert_metrics_recorded metric => {:call_count => 1}
   end
 
   def test_add_class_method_tracer
     in_transaction do
       MyClass.class_method
     end
-    stats = @stats_engine.get_stats("Custom/MyClass/Class/class_method")
-    assert stats.call_count == 1
+
+    metric = "Custom/MyClass/Class/class_method"
+    assert_metrics_recorded metric => {:call_count => 1}
   end
 
   def test_add_anonymous_class_method_tracer
@@ -208,8 +190,8 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
       cls.new.instance_method
     end
 
-    stats = @stats_engine.get_stats("Custom/AnonymousClass/instance_method")
-    assert stats.call_count == 1
+    metric = "Custom/AnonymousClass/instance_method"
+    assert_metrics_recorded metric => {:call_count => 1}
   end
 
   def test_add_method_tracer__reentry
@@ -221,8 +203,8 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
       simple_method
     end
 
-    stats = @stats_engine.get_stats("Custom/#{self.class.name}/simple_method")
-    assert stats.call_count == 1
+    metric = "Custom/#{self.class.name}/simple_method"
+    assert_metrics_recorded metric => {:call_count => 1}
   end
 
   def test_method_traced?
@@ -266,10 +248,11 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
       mock.catcher(5)
     end
 
-    stats = @stats_engine.get_stats("catcher")
-    assert_equal 2, stats.call_count
-    stats = @stats_engine.get_stats("thrower")
-    assert_equal 6, stats.call_count
+    assert_metrics_recorded({
+      "catcher" => {:call_count => 2},
+      "thrower" => {:call_count => 6}
+    })
+
     sample = @old_sampler.harvest!
     refute_nil sample
   end
@@ -292,9 +275,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
       # ignore 'no tracer' errors from remove method tracer
     end
 
-    stats = @stats_engine.get_stats(METRIC)
-    check_time 0.05, stats.total_call_time
-    assert_equal 1, stats.call_count
+    assert_metrics_recorded METRIC => {:call_count => 1, :total_call_time => 0.05}
   end
 
   def test_add_tracer_with_dynamic_metric
@@ -314,9 +295,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
       # ignore 'no tracer' errors from remove method tracer
     end
 
-    stats = @stats_engine.get_stats(expected_metric)
-    check_time 0.05, stats.total_call_time
-    assert_equal 1, stats.call_count
+    assert_metrics_recorded expected_metric => {:call_count => 1, :total_call_time => 0.05}
   end
 
   def test_trace_method_with_block
@@ -329,9 +308,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
       assert_equal METRIC, @scope_listener.scopes.last
     end
 
-    stats = @stats_engine.get_stats(METRIC)
-    check_time 0.15, stats.total_call_time
-    assert_equal 1, stats.call_count
+    assert_metrics_recorded METRIC => {:call_count => 1, :total_call_time => 0.15}
   end
 
   def test_trace_module_method
@@ -346,8 +323,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
 
     method_to_be_traced 1,2,3,false,METRIC
 
-    stats = @stats_engine.get_stats(METRIC)
-    assert stats.call_count == 0
+    assert_metrics_not_recorded METRIC
   end
 
   def self.static_method(x, testcase, is_traced)
@@ -371,11 +347,13 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
         advance_time 0.05
       end
     end
-    elapsed = @stats_engine.get_stats('first').total_call_time
-    metrics.map{|name| @stats_engine.get_stats name}.each do | m |
-      assert_equal 1, m.call_count
-      assert_equal elapsed, m.total_call_time
-    end
+
+
+    assert_metrics_recorded({
+      'first' => {:call_count => 1, :total_call_time => 0.05},
+      'second' => {:call_count => 1, :total_call_time => 0.05},
+      'third' => {:call_count => 1, :total_call_time => 0.05}
+    })
   end
 
   def test_multiple_metrics__unscoped
@@ -383,11 +361,12 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     self.class.trace_execution_unscoped metrics do
       advance_time 0.05
     end
-    elapsed = @stats_engine.get_stats('first').total_call_time
-    metrics.map{|name| @stats_engine.get_stats name}.each do | m |
-      assert_equal 1, m.call_count
-      assert_equal elapsed, m.total_call_time
-    end
+
+    assert_metrics_recorded({
+      'first' => {:call_count => 1, :total_call_time => 0.05},
+      'second' => {:call_count => 1, :total_call_time => 0.05},
+      'third' => {:call_count => 1, :total_call_time => 0.05}
+    })
     assert @scope_listener.scopes.empty?
   end
 
@@ -406,8 +385,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     rescue StandardError
     end
 
-    stats = @stats_engine.get_stats metric
-    assert_equal 1, stats.call_count
+    assert_metrics_recorded metric => {:call_count => 1}
   end
 
   def test_add_multiple_tracers
@@ -450,31 +428,12 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
 
     public_api_methods = [
       'trace_execution_unscoped',
-      'trace_execution_scoped',
-      'trace_method_execution',            # deprecated
-      'trace_method_execution_with_scope', # deprecated
-      'trace_method_execution_no_scope',   # deprecated
-      'get_stats_scoped',                  # deprecated
-      'get_stats_unscoped'                 # deprecated
+      'trace_execution_scoped'
     ]
 
     assert_equal(public_api_methods.sort, added_methods.map(&:to_s).sort)
   end
 
-  def test_get_stats_unscoped
-    host_class = Class.new { include ::NewRelic::Agent::MethodTracer }
-    expected_stats = NewRelic::Agent.get_stats('foobar')
-    stats = host_class.new.get_stats_unscoped('foobar')
-    assert_same(expected_stats, stats)
-  end
-
-  def test_get_stats_scoped
-    host_class = Class.new { include ::NewRelic::Agent::MethodTracer }
-    expected_stats = NewRelic::Agent.get_stats('foobar', true)
-    stats = host_class.new.get_stats_scoped('foobar', false)
-    assert_same(expected_stats, stats)
-  end
-
   def trace_no_push_scope
     self.class.add_method_tracer :method_to_be_traced, 'X', :push_scope => false
     method_to_be_traced 1,2,3,true,nil