sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/agent/sampler_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+class NewRelic::Agent::SamplerTest < Test::Unit::TestCase
+  require 'new_relic/agent/sampler'
+
+  def test_inherited_should_append_subclasses_to_sampler_classes
+    test_class = Class.new(NewRelic::Agent::Sampler)
+    sampler_classes = NewRelic::Agent::Sampler.instance_eval { @sampler_classes }
+    assert(sampler_classes.include?(test_class), "Sampler classes (#{@sampler_classes.inspect}) does not include #{test_class.inspect}")
+    # cleanup the sampler created above
+    NewRelic::Agent::Sampler.instance_eval { @sampler_classes.delete(test_class) }
+  end
+
+  def test_sampler_classes_should_be_an_array
+    sampler_classes = NewRelic::Agent::Sampler.instance_variable_get('@sampler_classes')
+    assert(sampler_classes.is_a?(Array), 'Sampler classes should be saved as an array')
+    assert(sampler_classes.include?(NewRelic::Agent::Samplers::CpuSampler), 'Sampler classes should include the CPU sampler')
+  end
+
+end

data/test/new_relic/agent/shim_agent_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+module NewRelic
+  module Agent
+    class ShimAgentTest < Test::Unit::TestCase
+
+      def setup
+        super
+        @agent = NewRelic::Agent::ShimAgent.new
+      end
+
+      def test_merge_data_from
+        assert_equal(nil, @agent.merge_data_from(mock('metric data')))
+      end
+    end
+  end
+end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -0,0 +1,244 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
+  def setup
+    agent = NewRelic::Agent.instance
+    stats_engine = NewRelic::Agent::StatsEngine.new
+    agent.stubs(:stats_engine).returns(stats_engine)
+    @sampler = NewRelic::Agent::SqlSampler.new
+    @connection = stub('ActiveRecord connection', :execute => 'result')
+    NewRelic::Agent::Database.stubs(:get_connection).returns(@connection)
+  end
+
+  def test_notice_first_scope_push
+    assert_nil @sampler.transaction_data
+    @sampler.notice_first_scope_push nil
+    assert_not_nil @sampler.transaction_data
+    @sampler.notice_scope_empty
+    assert_nil @sampler.transaction_data
+  end
+
+  def test_notice_sql_no_transaction
+    assert_nil @sampler.transaction_data
+    @sampler.notice_sql "select * from test", "Database/test/select", nil, 10
+  end
+
+  def test_notice_sql
+    @sampler.notice_first_scope_push nil
+    @sampler.notice_sql "select * from test", "Database/test/select", nil, 1.5
+    @sampler.notice_sql "select * from test2", "Database/test2/select", nil, 1.3
+    # this sql will not be captured
+    @sampler.notice_sql "select * from test", "Database/test/select", nil, 0
+    assert_not_nil @sampler.transaction_data
+    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", {},
+                              'guid')
+    data.sql_data.concat [
+      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
+      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
+      NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)
+    ]
+    @sampler.harvest_slow_sql data
+
+    assert_equal 2, @sampler.sql_traces.size
+  end
+
+  def test_sql_aggregation
+    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test",
+            NewRelic::Agent::SlowSql.new("select * from test",
+                "Database/test/select", {}, 1.2),
+        "tx_name", "uri")
+
+    sql_trace.aggregate NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), "slowest_tx_name", "slow_uri"
+    sql_trace.aggregate NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.1), "other_tx_name", "uri2"
+
+    assert_equal 3, sql_trace.call_count
+    assert_equal "slowest_tx_name", sql_trace.path
+    assert_equal "slow_uri", sql_trace.url
+    assert_equal 1.5, sql_trace.max_call_time
+  end
+
+  def test_harvest
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                              'guid')
+    data.sql_data.concat [NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
+                          NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
+                          NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)]
+    @sampler.harvest_slow_sql data
+
+    sql_traces = @sampler.harvest
+    assert_equal 2, sql_traces.size
+  end
+
+  def test_harvest_should_not_take_more_than_10
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {}, 'guid')
+    15.times do |i|
+      data.sql_data << NewRelic::Agent::SlowSql.new("select * from test#{(i+97).chr}",
+                                                    "Database/test#{(i+97).chr}/select", {}, i)
+    end
+
+    @sampler.harvest_slow_sql data
+    result = @sampler.harvest
+
+    assert_equal(10, result.size)
+    assert_equal(14, result.sort{|a,b| b.max_call_time <=> a.max_call_time}.first.total_call_time)
+  end
+
+  def test_harvest_should_aggregate_similar_queries
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                              'guid')
+    queries = [
+               NewRelic::Agent::SlowSql.new("select  * from test where foo in (1, 2)  ", "Database/test/select", {}, 1.5),
+               NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2, 3 ,4,  5,6, 'snausage')", "Database/test/select", {}, 1.2),
+               NewRelic::Agent::SlowSql.new("select * from test2 where foo in (1,2)", "Database/test2/select", {}, 1.1)
+              ]
+    data.sql_data.concat(queries)
+    @sampler.harvest_slow_sql data
+
+    sql_traces = @sampler.harvest
+    assert_equal 2, sql_traces.size
+  end
+
+  def test_harvest_should_collect_explain_plans
+    @connection.expects(:execute).with("EXPLAIN select * from test") \
+     .returns([{"header0" => 'foo0', "header1" => 'foo1', "header2" => 'foo2'}])
+    @connection.expects(:execute).with("EXPLAIN select * from test2") \
+     .returns([{"header0" => 'bar0', "header1" => 'bar1', "header2" => 'bar2'}])
+
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                              'guid')
+    queries = [
+               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
+               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
+               NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)
+              ]
+    data.sql_data.concat(queries)
+    @sampler.harvest_slow_sql data
+    sql_traces = @sampler.harvest
+    assert_equal(["header0", "header1", "header2"],
+                 sql_traces[0].params[:explain_plan][0].sort)
+    assert_equal(["header0", "header1", "header2"],
+                 sql_traces[1].params[:explain_plan][0].sort)
+    assert_equal(["foo0", "foo1", "foo2"],
+                 sql_traces[0].params[:explain_plan][1][0].sort)
+    assert_equal(["bar0", "bar1", "bar2"],
+                 sql_traces[1].params[:explain_plan][1][0].sort)
+  end
+
+  def test_sql_trace_should_include_transaction_guid
+    txn_sampler = NewRelic::Agent::TransactionSampler.new
+    NewRelic::Agent.instance.stats_engine.transaction_sampler = txn_sampler
+    txn_sampler.start_builder(Time.now)
+    txn_sampler.notice_transaction('a path', 'a uri', {:some => :params})
+    @sampler.create_transaction_data
+    @sampler.notice_transaction('a path', 'a uri', {:some => :params})
+
+    assert_equal(NewRelic::Agent.instance.transaction_sampler.builder.sample.guid,
+                 NewRelic::Agent.instance.sql_sampler.transaction_data.guid)
+  end
+
+  def test_should_not_collect_explain_plans_when_disabled
+    with_config(:'transaction_tracer.explain_enabled' => false) do
+      data = NewRelic::Agent::TransactionSqlData.new
+      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                                'guid')
+
+      queries = [
+                 NewRelic::Agent::SlowSql.new("select * from test",
+                                              "Database/test/select", {}, 1.5)
+                ]
+      data.sql_data.concat(queries)
+      @sampler.harvest_slow_sql data
+      sql_traces = @sampler.harvest
+      assert_equal(nil, sql_traces[0].params[:explain_plan])
+    end
+  end
+
+  def test_sql_id_fits_in_a_mysql_int_11
+    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test",
+            NewRelic::Agent::SlowSql.new("select * from test",
+                "Database/test/select", {}, 1.2),
+        "tx_name", "uri")
+
+    assert -2147483648 <= sql_trace.sql_id, "sql_id too small"
+    assert 2147483647 >= sql_trace.sql_id, "sql_id too large"
+  end
+
+  def test_sends_obfuscated_queries_when_configured
+    with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
+      data = NewRelic::Agent::TransactionSqlData.new
+      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                                'guid')
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test where foo = 'bar'",
+                                                         "Database/test/select", {}, 1.5),
+                            NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
+                                                         "Database/test/select", {}, 1.2)])
+      @sampler.harvest_slow_sql(data)
+      sql_traces = @sampler.harvest
+
+      assert_equal('select * from test where foo = ?', sql_traces[0].sql)
+      assert_equal('select * from test where foo in (?,?,?,?,?)', sql_traces[1].sql)
+    end
+  end
+
+  def test_to_collector_array
+    with_config(:'transaction_tracer.explain_enabled' => false) do
+      data = NewRelic::Agent::TransactionSqlData.new
+      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                                'guid')
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test",
+                                                         "Database/test/select",
+                                                         {}, 1.5)])
+      @sampler.harvest_slow_sql(data)
+      sql_traces = @sampler.harvest
+
+      params = RUBY_VERSION >= '1.9.2' ? "eJyrrgUAAXUA+Q==\n" : {}
+      expected = [ 'WebTransaction/Controller/c/a', '/c/a', 526336943,
+                   'select * from test', 'Database/test/select',
+                   1, 1500, 1500, 1500, params ]
+
+      if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+        marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      else
+        marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+      end
+
+      assert_equal expected, sql_traces[0].to_collector_array(marshaller.default_encoder)
+    end
+  end
+
+  def test_to_collector_array_with_bad_values
+    slow = NewRelic::Agent::SlowSql.new("query", "transaction", {}, Rational(12, 1))
+    trace = NewRelic::Agent::SqlTrace.new("query", slow, "path", "uri")
+    trace.call_count = Rational(10, 1)
+    trace.instance_variable_set(:@sql_id, "1234")
+
+    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    else
+      marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    end
+
+    params = RUBY_VERSION >= '1.9.2' ? "eJyrrgUAAXUA+Q==\n" : {}
+    expected = [ "path", "uri", 1234, "query", "transaction",
+                 10, 12000, 12000, 12000, params]
+
+    assert_equal expected, trace.to_collector_array(marshaller.default_encoder)
+  end
+
+end

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

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

@@ -0,0 +1,180 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
+  def setup
+    NewRelic::Agent.manual_start
+    @engine = NewRelic::Agent.instance.stats_engine
+  rescue => e
+    puts e
+    puts e.backtrace.join("\n")
+  end
+
+  def teardown
+    @engine.harvest_timeslice_data({})
+    super
+  end
+
+  def test_get_no_scope
+    s1 = @engine.get_stats "a"
+    s2 = @engine.get_stats "a"
+    s3 = @engine.get_stats "b"
+
+    assert_not_nil s1
+    assert_not_nil s2
+    assert_not_nil s3
+
+    assert s1 == s2
+    assert_not_same(s1, s3)
+  end
+
+  def test_harvest
+    @engine.clear_stats
+    s1 = @engine.get_stats "a"
+    s2 = @engine.get_stats "c"
+
+    s1.trace_call 10
+    s2.trace_call 1
+    s2.trace_call 3
+
+    assert_equal 1, @engine.get_stats("a").call_count
+    assert_equal 10, @engine.get_stats("a").total_call_time
+
+    assert_equal 2, @engine.get_stats("c").call_count
+    assert_equal 4, @engine.get_stats("c").total_call_time
+
+    harvested = @engine.harvest_timeslice_data({})
+
+    # after harvest, all the metrics should be reset
+    assert_equal 0, @engine.get_stats("a").call_count
+    assert_equal 0, @engine.get_stats("a").total_call_time
+    assert_equal 0, @engine.get_stats("c").call_count
+    assert_equal 0, @engine.get_stats("c").total_call_time
+
+    spec_a = NewRelic::MetricSpec.new('a')
+    assert(harvested.has_key?(spec_a))
+    assert_equal(1, harvested[spec_a].call_count)
+    assert_equal(10, harvested[spec_a].total_call_time)
+  end
+
+  def test_harvest_timeslice_data_applies_metric_rename_rules
+    rule = NewRelic::Agent::RulesEngine::Rule.new(
+      'match_expression' => '[0-9]+',
+      'replacement'      => '*',
+      'replace_all'      => true
+    )
+    rules_engine = NewRelic::Agent::RulesEngine.new([rule])
+
+    @engine.get_stats_no_scope('Custom/foo/1/bar/22').record_data_point(1)
+    @engine.get_stats_no_scope('Custom/foo/3/bar/44').record_data_point(1)
+    @engine.get_stats_no_scope('Custom/foo/5/bar/66').record_data_point(1)
+
+    harvested = @engine.harvest_timeslice_data({}, rules_engine)
+
+    assert !harvested.has_key?(NewRelic::MetricSpec.new('Custom/foo/1/bar/22'))
+    assert !harvested.has_key?(NewRelic::MetricSpec.new('Custom/foo/3/bar/44'))
+    assert !harvested.has_key?(NewRelic::MetricSpec.new('Custom/foo/5/bar/66'))
+    merged = harvested[NewRelic::MetricSpec.new('Custom/foo/*/bar/*')]
+    assert_equal(3, merged.call_count)
+  end
+
+  def test_harvest_with_merge
+    s = @engine.get_stats "a"
+    s.trace_call 1
+    assert_equal 1, @engine.get_stats("a").call_count
+
+    harvest = @engine.harvest_timeslice_data({})
+
+    s = @engine.get_stats "a"
+    assert_equal 0, s.call_count
+    s.trace_call 2
+    assert_equal 1, s.call_count
+
+    # this call should merge the contents of the previous harvest,
+    # so the stats for metric "a" should have 2 data points
+    harvest = @engine.harvest_timeslice_data(harvest)
+    stats = harvest.fetch(NewRelic::MetricSpec.new("a"))
+    assert_equal 2, stats.call_count
+    assert_equal 3, stats.total_call_time
+  end
+
+  def test_merge_merges
+    @engine.get_stats("foo").record_data_point(1)
+
+    other_stats_hash = NewRelic::Agent::StatsHash.new()
+    other_stats_hash.record(NewRelic::MetricSpec.new('foo'), 1)
+    other_stats_hash.record(NewRelic::MetricSpec.new('bar'), 1)
+
+    @engine.merge!(other_stats_hash)
+
+    foo_stats = @engine.get_stats('foo')
+    bar_stats = @engine.get_stats('bar')
+    assert_equal(2, foo_stats.call_count)
+    assert_equal(1, bar_stats.call_count)
+  end
+
+  def test_record_metric_unscoped_metrics_only_by_default
+    @engine.stubs(:default_scope).returns('scopey')
+    @engine.record_metric('foo', 42)
+    unscoped_stats = @engine.get_stats('foo', false)
+    scoped_stats = @engine.get_stats('foo', true, true, 'scopey')
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(0, scoped_stats.call_count)
+  end
+
+  def test_record_metric_records_to_scoped_metric_if_requested
+    @engine.stubs(:default_scope).returns('scopey')
+    @engine.record_metric('foo', 42, :scoped => true)
+    unscoped_stats = @engine.get_stats('foo', false)
+    scoped_stats = @engine.get_stats('foo', true, true, 'scopey')
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(1, scoped_stats.call_count)
+  end
+
+  def test_record_metric_elides_scoped_metric_if_not_in_transaction
+    @engine.clear_stats
+    @engine.stubs(:default_scope).returns(nil)
+    @engine.record_metric('foo', 42, :scoped => true)
+    unscoped_stats = @engine.get_stats('foo', false)
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(1, @engine.metrics.size)
+  end
+
+  def test_record_metric_accepts_explicit_scope
+    @engine.stubs(:default_scope).returns('scopey')
+    @engine.record_metric('foo', 42, :scoped => true, :scope => 'not scopey')
+    unscoped_stats = @engine.get_stats('foo', false)
+    scoped_stats_scopey = @engine.get_stats('foo', true, true, 'scopey')
+    scoped_stats_not_scopey = @engine.get_stats('foo', true, true, 'not scopey')
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(0, scoped_stats_scopey.call_count)
+    assert_equal(1, scoped_stats_not_scopey.call_count)
+  end
+
+  def test_record_metric_accepts_block
+    @engine.record_metric('foo') do |stats|
+      stats.call_count = 999
+    end
+    stats = @engine.get_stats_no_scope('foo')
+    assert_equal(999, stats.call_count)
+  end
+
+  def test_record_metric_is_thread_safe
+    threads = []
+    nthreads = 25
+    iterations = 100
+    nthreads.times do |tid|
+      threads << Thread.new do
+        iterations.times do
+          @engine.record_metric('m1', 1)
+          @engine.record_metric('m2', 1)
+        end
+      end
+    end
+    threads.each { |t| t.join }
+
+    stats_m1 = @engine.get_stats_no_scope('m1')
+    stats_m2 = @engine.get_stats_no_scope('m2')
+    assert_equal(nthreads * iterations, stats_m1.call_count)
+    assert_equal(nthreads * iterations, stats_m2.call_count)
+  end
+end