newrelic_rpm 3.5.7.59 → 3.5.8.64.beta

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

@@ -16,7 +16,7 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
       expected_but_missing = stat_names - @agent.stats_engine.metrics
       assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
         stat = @agent.stats_engine.get_stats_no_scope(n)
-      "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+      "#{'%-26s' % n}: #{stat.call_count} calls"
       }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
       assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
       assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
@@ -44,7 +44,6 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
       run_task_outer(3)
       @agent.stats_engine.metrics.sort.each do |n|
         stat = @agent.stats_engine.get_stats_no_scope(n)
-        #      puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
       end
       assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
       assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
@@ -70,7 +69,6 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
       assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
       @agent.stats_engine.metrics.sort.each do |n|
         stat = @agent.stats_engine.get_stats_no_scope(n)
-        #      puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
       end
       assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
       assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
@@ -101,7 +99,6 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
       end
       @agent.stats_engine.metrics.sort.each do |n|
         stat = @agent.stats_engine.get_stats_no_scope(n)
-        #puts "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
       end
       assert_equal @agent, NewRelic::Agent.instance
       assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello').call_count
@@ -146,7 +143,7 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
       expected_but_missing = stat_names - @agent.stats_engine.metrics
       assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
         stat = @agent.stats_engine.get_stats_no_scope(n)
-      "#{'%-26s' % n}: #{stat.call_count} calls @ #{stat.average_call_time} sec/call"
+      "#{'%-26s' % n}: #{stat.call_count} calls"
       }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
       assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/all').call_count
       assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/Background/all').call_count

data/test/new_relic/agent/method_tracer_test.rb

@@ -59,6 +59,8 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   attr_reader :stats_engine
 
   def setup
+    Thread::current[:newrelic_scope_stack] = nil
+
     NewRelic::Agent.manual_start
     @stats_engine = NewRelic::Agent.instance.stats_engine
     @stats_engine.clear_stats
@@ -288,7 +290,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     self.class.trace_execution_scoped metrics do
       sleep 0.05
     end
-    elapsed = @stats_engine.get_stats('first').average_call_time
+    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
@@ -299,7 +301,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     self.class.trace_execution_unscoped metrics do
       sleep 0.05
     end
-    elapsed = @stats_engine.get_stats('first').average_call_time
+    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

data/test/new_relic/agent/new_relic_service_test.rb

@@ -197,9 +197,44 @@ class NewRelicServiceTest < Test::Unit::TestCase
   end
 
   def test_metric_data
-    @http_handle.respond_to(:metric_data, 'met rick date uhhh')
-    response = @service.metric_data((Time.now - 60).to_f, Time.now.to_f, {})
-    assert_equal 'met rick date uhhh', response
+    dummy_rsp = 'met rick date uhh'
+    @http_handle.respond_to(:metric_data, dummy_rsp)
+    stats_hash = NewRelic::Agent::StatsHash.new
+    @service.expects(:fill_metric_id_cache).with(dummy_rsp)
+    response = @service.metric_data((Time.now - 60).to_f, Time.now.to_f, stats_hash)
+    assert_equal dummy_rsp, response
+  end
+
+  def test_fill_metric_id_cache_from_collect_response
+    response = [[{"scope"=>"Controller/blogs/index", "name"=>"Database/SQL/other"}, 1328],
+                [{"scope"=>"", "name"=>"WebFrontend/QueueTime"}, 10],
+                [{"scope"=>"", "name"=>"ActiveRecord/Blog/find"}, 1017]]
+
+    @service.send(:fill_metric_id_cache, response)
+
+    cache = @service.metric_id_cache
+    assert_equal 1328, cache[NewRelic::MetricSpec.new('Database/SQL/other', 'Controller/blogs/index')]
+    assert_equal 10,   cache[NewRelic::MetricSpec.new('WebFrontend/QueueTime')]
+    assert_equal 1017, cache[NewRelic::MetricSpec.new('ActiveRecord/Blog/find')]
+  end
+
+  def test_caches_metric_ids_for_future_use
+    dummy_rsp = [[{ 'name' => 'a', 'scope' => '' }, 42]]
+    @http_handle.respond_to(:metric_data, dummy_rsp)
+
+    hash = NewRelic::Agent::StatsHash.new
+    hash.record(NewRelic::MetricSpec.new('a'), 1)
+
+    @service.metric_data((Time.now - 60).to_f, Time.now.to_f, hash)
+
+    hash = NewRelic::Agent::StatsHash.new
+    hash.record(NewRelic::MetricSpec.new('a'), 1)
+    stats = hash[NewRelic::MetricSpec.new('a')]
+
+    results = @service.build_metric_data_array(hash)
+    assert_nil(results.first.metric_spec)
+    assert_equal(stats, results.first.stats)
+    assert_equal(42, results.first.metric_id)
   end
 
   def test_error_data
@@ -276,7 +311,9 @@ end
 
     @service.connect
     @http_handle.respond_to(:metric_data, 0)
-    @service.metric_data((Time.now - 60).to_f, Time.now.to_f, {})
+    @service.stubs(:fill_metric_id_cache)
+    stats_hash = NewRelic::Agent::StatsHash.new
+    @service.metric_data((Time.now - 60).to_f, Time.now.to_f, stats_hash)
 
     @http_handle.respond_to(:transaction_sample_data, 1)
     @service.transaction_sample_data([])
@@ -298,7 +335,8 @@ end
   def test_should_raise_exception_on_413
     @http_handle.respond_to(:metric_data, 'too big', :code => 413)
     assert_raise NewRelic::Agent::UnrecoverableServerException do
-      @service.metric_data((Time.now - 60).to_f, Time.now.to_f, {})
+      stats_hash = NewRelic::Agent::StatsHash.new
+      @service.metric_data((Time.now - 60).to_f, Time.now.to_f, stats_hash)
     end
   end
 
@@ -306,7 +344,8 @@ end
   def test_should_raise_exception_on_415
     @http_handle.respond_to(:metric_data, 'too big', :code => 415)
     assert_raise NewRelic::Agent::UnrecoverableServerException do
-      @service.metric_data((Time.now - 60).to_f, Time.now.to_f, {})
+      stats_hash = NewRelic::Agent::StatsHash.new
+      @service.metric_data((Time.now - 60).to_f, Time.now.to_f, stats_hash)
     end
   end
 
@@ -323,6 +362,18 @@ end
         marshaller.load('{"exception": {"message": "error message", "error_type": "JavaCrash"}}')
       end
     end
+
+    def test_use_pruby_marshaller_if_error_using_json
+      json_marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      @service.instance_variable_set(:@marshaller, json_marshaller)
+      JSON.stubs(:dump).raises(RuntimeError.new('blah'))
+      @http_handle.respond_to(:transaction_sample_data, 'ok', :format => :pruby)
+
+      @service.transaction_sample_data([])
+
+      assert_equal('NewRelic::Agent::NewRelicService::PrubyMarshaller',
+                   @service.marshaller.class.name)
+    end
   end
 
   def test_pruby_marshaller_handles_errors_from_collector
@@ -392,6 +443,57 @@ end
     assert_equal 'OogBooga: test', error.message
   end
 
+  def test_build_metric_data_array
+    hash = NewRelic::Agent::StatsHash.new
+
+    spec1 = NewRelic::MetricSpec.new('foo')
+    spec2 = NewRelic::MetricSpec.new('bar')
+    hash.record(spec1, 1)
+    hash.record(spec2, 2)
+
+    metric_data_array = @service.build_metric_data_array(hash)
+
+    assert_equal(2, metric_data_array.size)
+    metric_data_1 = metric_data_array.find { |md| md.metric_spec == spec1 }
+    metric_data_2 = metric_data_array.find { |md| md.metric_spec == spec2 }
+    assert_equal(hash[spec1], metric_data_1.stats)
+    assert_equal(hash[spec2], metric_data_2.stats)
+  end
+
+  def test_build_metric_data_array_uses_metric_id_cache_if_possible
+    hash = NewRelic::Agent::StatsHash.new
+
+    spec1 = NewRelic::MetricSpec.new('foo')
+    spec2 = NewRelic::MetricSpec.new('bar')
+    hash.record(spec1, 1)
+    hash.record(spec2, 1)
+
+    @service.stubs(:metric_id_cache).returns({ spec1 => 42 })
+    metric_data_array = @service.build_metric_data_array(hash)
+
+    assert_equal(2, metric_data_array.size)
+
+    metric_data1 = metric_data_array.find { |md| md.metric_id == 42 }
+    metric_data2 = metric_data_array.find { |md| md.metric_spec == spec2 }
+    assert_nil(metric_data1.metric_spec)
+    assert_nil(metric_data2.metric_id)
+  end
+
+  def test_build_metric_data_array_omits_empty_stats
+    hash = NewRelic::Agent::StatsHash.new
+
+    spec1 = NewRelic::MetricSpec.new('foo')
+    spec2 = NewRelic::MetricSpec.new('bar')
+    hash.record(spec1, 1)
+    hash[spec2] = NewRelic::Agent::Stats.new()
+
+    metric_data_array = @service.build_metric_data_array(hash)
+    assert_equal(1, metric_data_array.size)
+
+    metric_data = metric_data_array.first
+    assert_equal(spec1, metric_data.metric_spec)
+  end
+
   class HTTPHandle
     attr_accessor :read_timeout, :route_table
 

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -39,7 +39,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
         NewRelic::Agent.after_fork
         new_engine = NewRelic::Agent::StatsEngine.new
         new_engine.get_stats_no_scope(metric).record_data_point(2.0)
-        listener.pipes[666].write(:stats => new_engine.harvest_timeslice_data({}, {}))
+        listener.pipes[666].write(:stats => new_engine.harvest_timeslice_data({}))
       end
       Process.wait(pid)
       listener.stop

data/test/new_relic/agent/pipe_service_test.rb

@@ -2,15 +2,15 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_hel
 
 class PipeServiceTest < Test::Unit::TestCase
   def setup
-    NewRelic::Agent::PipeChannelManager.listener.stop    
+    NewRelic::Agent::PipeChannelManager.listener.stop
     NewRelic::Agent::PipeChannelManager.register_report_channel(:pipe_service_test)
     @service = NewRelic::Agent::PipeService.new(:pipe_service_test)
   end
-  
+
   def test_constructor
     assert_equal :pipe_service_test, @service.channel_id
   end
-  
+
   def test_connect_returns_nil
     assert_nil @service.connect({}) 
   end
@@ -75,13 +75,13 @@ class PipeServiceTest < Test::Unit::TestCase
         @service.metric_data(0.0, 0.1, metric_data0)
         @service.transaction_sample_data(['txn0'])
         @service.error_data(['err0'])
-        @service.sql_trace_data(['sql0'])      
+        @service.sql_trace_data(['sql0'])
         @service.shutdown(Time.now)
       end
       Process.wait(pid)
-      
+
       received_data = read_from_pipe
-      
+
       assert_equal 'Custom/something', received_data[:stats].keys.sort[0].name
       assert_equal ['txn0'], received_data[:transaction_traces]
       assert_equal ['err0'], received_data[:error_traces].sort
@@ -93,7 +93,7 @@ class PipeServiceTest < Test::Unit::TestCase
       end
       assert_equal 'EOF', received_data[:EOF]
     end
-    
+
     def test_shutdown_closes_pipe
       data_from_forked_process do
         @service.shutdown(Time.now)
@@ -102,11 +102,11 @@ class PipeServiceTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   def generate_metric_data(metric_name, data=1.0)
     engine = NewRelic::Agent::StatsEngine.new
     engine.get_stats_no_scope(metric_name).record_data_point(data)
-    engine.harvest_timeslice_data({}, {}).values
+    engine.harvest_timeslice_data({})
   end
 
   def read_from_pipe

data/test/new_relic/agent/rpm_agent_test.rb

@@ -83,17 +83,6 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
       NewRelic::Agent.shutdown
     end
 
-    should "send_timeslice_data" do
-      # this test fails due to a rubinius bug
-      return if NewRelic::LanguageSupport.using_engine?('rbx')
-      @agent.service.expects(:metric_data).returns([ [{'name' => '/A/b/c'}, 1],
-                                                     [{'name' => '/A/b/c', 'scope' => '/X'}, 2],
-                                                     [{'name' => '/A/b/d'}, 3] ])
-      @agent.send :harvest_and_send_timeslice_data
-      assert_equal 3, @agent.metric_ids.size
-      assert_equal(3, @agent.metric_ids[NewRelic::MetricSpec.new('/A/b/d')],
-                   @agent.metric_ids.inspect)
-    end
     should "set_record_sql" do
       @agent.set_record_sql(false)
       assert !NewRelic::Agent.is_sql_recorded?

data/test/new_relic/agent/rules_engine_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class RulesEngineTest < Test::Unit::TestCase
+  def setup
+    @engine = NewRelic::Agent::RulesEngine.new
+  end
+
+  def test_rule_defaults
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '.*',
+                                                  'replacement'      => '*')
+    assert !rule.terminate_chain
+    assert !rule.each_segment
+    assert !rule.ignore
+    assert !rule.replace_all
+    assert_equal 0, rule.eval_order
+  end
+
+  def test_rule_applies_regex_rename
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                  'replacement'      => '*')
+    assert_equal(['foo/*/bar/22', true], rule.apply('foo/1/bar/22'))
+  end
+
+  def test_rule_applies_grouping_with_replacements
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '([0-9]+)',
+                                                  'replacement'      => '\\1\\1')
+    assert_equal(['foo/11/bar/22', true], rule.apply('foo/1/bar/22'))
+  end
+
+  def test_rule_renames_all_matches_when_replace_all_is_true
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                  'replacement'      => '*',
+                                                  'replace_all'      => true)
+    assert_equal(['foo/*/bar/*', true], rule.apply('foo/1/bar/22'))
+  end
+
+  def test_rule_with_no_match
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => 'QQ',
+                                                  'replacement'      => 'qq')
+    assert_equal(['foo/1/bar/22', false], rule.apply('foo/1/bar/22'))
+  end
+
+  def test_applies_rules_in_order
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                  'replacement'      => '*',
+                                                  'replace_all'      => true,
+                                                  'eval_order'       => 0)
+    rerule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '\*',
+                                                    'replacement'      => 'x',
+                                                    'replace_all'      => true,
+                                                    'eval_order'       => 1)
+    @engine << rerule
+    @engine << rule
+
+    assert_equal('foo/x/bar/x', @engine.rename('foo/1/bar/22'))
+  end
+
+  def test_can_apply_rules_to_all_segments
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+.*',
+                                                  'replacement'      => '*',
+                                                  'each_segment'     => true)
+    @engine << rule
+
+    assert_equal('foo/*/bar/*', @engine.rename('foo/1a/bar/22b'))
+  end
+
+  def test_stops_after_terminate_chain
+    rule0 = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                   'replacement'      => '*',
+                                                   'each_segment'     => true,
+                                                   'eval_order'       => 0,
+                                                   'terminate_chain'  => true)
+    rule1 = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '.*',
+                                                   'replacement'      => 'X',
+                                                   'replace_all'      => true,
+                                                   'eval_order'       => 1)
+    @engine << rule0
+    @engine << rule1
+
+    assert_equal('foo/*/bar/*', @engine.rename('foo/1/bar/22'))
+  end
+end

data/test/new_relic/agent/shim_agent_test.rb

@@ -8,10 +8,6 @@ module NewRelic
         @agent = NewRelic::Agent::ShimAgent.new
       end
 
-      def test_serialize
-        assert_equal(nil, @agent.serialize, "should return nil when shut down")
-      end
-
       def test_merge_data_from
         assert_equal(nil, @agent.merge_data_from(mock('metric data')))
       end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -33,6 +33,13 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     assert_equal 2, @sampler.transaction_data.sql_data.size
   end
 
+  def test_notice_sql_truncates_query
+    @sampler.notice_first_scope_push nil
+    message = 'a' * 17_000
+    @sampler.notice_sql message, "Database/test/select", nil, 1.5
+    assert_equal('a' * 16_381 + '...', @sampler.transaction_data.sql_data[0].sql)
+  end
+
   def test_harvest_slow_sql
     data = NewRelic::Agent::TransactionSqlData.new
     data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},

data/test/new_relic/agent/stats_engine/gc_profiler_test.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+class NewRelic::Agent::StatsEngine::GCProfilerTest < Test::Unit::TestCase
+  def test_init_profiler_for_rails_bench
+    ::GC.stubs(:time)
+    ::GC.stubs(:collections)
+
+    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::RailsBench,
+                 NewRelic::Agent::StatsEngine::GCProfiler.init.class)
+  end
+
+  def test_init_profiler_for_ruby_19
+    defined = defined?(::GC::Profiler)
+    if !defined
+      ::GC.const_set(:Profiler, Module.new)
+    end
+    ::GC::Profiler.stubs(:enabled?).returns(true)
+    ::GC::Profiler.stubs(:total_time).returns(0)
+    ::GC.stubs(:count).returns(0)
+
+    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::Ruby19,
+                 NewRelic::Agent::StatsEngine::GCProfiler.init.class)
+  ensure
+    ::GC.send(:remove_const, :Profiler) unless defined
+  end
+
+  def test_init_profiler_for_rbx
+    defined = defined?(::Rubinius::GC)
+    if !defined
+      Object.const_set(:Rubinius, Module.new)
+      ::Rubinius.const_set(:GC, Module.new)
+    end
+    ::Rubinius::GC.stubs(:count).returns(0)
+    ::Rubinius::GC.stubs(:time).returns(0)
+
+    assert_equal(NewRelic::Agent::StatsEngine::GCProfiler::Rubinius,
+                 NewRelic::Agent::StatsEngine::GCProfiler.init.class)
+  ensure
+    Object.send(:remove_const, :Rubinius) unless defined
+  end
+
+  def test_collect_gc_data
+    GC.disable unless NewRelic::LanguageSupport.using_engine?('jruby')
+    if NewRelic::LanguageSupport.using_engine?('rbx')
+      agent = ::Rubinius::Agent.loopback
+      agent.stubs(:get).with('system.gc.young.total_wallclock') \
+        .returns([:value, 1000], [:value, 2500])
+      agent.stubs(:get).with('system.gc.full.total_wallclock') \
+        .returns([:value, 2000], [:value, 3500])
+      agent.stubs(:get).with('system.gc.young.count') \
+        .returns([:value, 1], [:value, 2])
+      agent.stubs(:get).with('system.gc.full.count') \
+        .returns([:value, 1], [:value, 2])
+      ::Rubinius::Agent.stubs(:loopback).returns(agent)
+    elsif NewRelic::LanguageSupport.using_version?('1.9')
+      ::GC::Profiler.stubs(:enabled?).returns(true)
+      ::GC::Profiler.stubs(:total_time).returns(1.0, 4.0)
+      ::GC.stubs(:count).returns(1, 3)
+      ::GC::Profiler.stubs(:clear).returns(nil)
+    elsif NewRelic::LanguageSupport.using_version?('1.8.7') &&
+        RUBY_DESCRIPTION =~ /Ruby Enterprise Edition/
+      ::GC.stubs(:time).returns(1000000, 4000000)
+      ::GC.stubs(:collections).returns(1, 3)
+    else
+      return true # no need to test if we're not collecting GC metrics
+    end
+
+    engine = NewRelic::Agent.instance.stats_engine
+    tracer = NewRelic::Agent::TransactionSampler.new
+    tracer.instance_variable_set(:@last_sample,
+                                 NewRelic::TransactionSample.new)
+    engine.transaction_sampler = tracer
+    engine.start_transaction
+    scope = engine.push_scope "scope"
+    engine.pop_scope scope, 0.01
+    engine.end_transaction
+
+    gc_stats = engine.get_stats('GC/cumulative')
+    assert_equal 2, gc_stats.call_count
+    assert_equal 3.0, gc_stats.total_call_time
+    assert_equal(3.0, tracer.last_sample.params[:custom_params][:gc_time])
+  ensure
+    GC.enable unless NewRelic::LanguageSupport.using_engine?('jruby')
+  end
+end