newrelic_rpm 3.8.1.221 → 3.9.0.229

data/test/new_relic/agent/rpm_agent_test.rb

@@ -28,34 +28,34 @@ class NewRelic::Agent::RpmAgentTest < Minitest::Test
     end
 
     ignore_called = false
-    NewRelic::Agent.ignore_error_filter do |e|
+    filter = Proc.new do |e|
       ignore_called = true
       nil
     end
-    NewRelic::Agent.notice_error(StandardError.new("message"), :request_params => {:x => "y"})
-
-    # Clean up after ourselves
-    NewRelic::Agent.instance.error_collector.instance_variable_set(:@ignore_filter, nil)
+    with_ignore_error_filter(filter) do
+      NewRelic::Agent.notice_error(StandardError.new("message"), :request_params => {:x => "y"})
+    end
 
     assert(ignore_called)
   end
 
-  def test_startup_shutdown
+  def test_startup_shutdown_shim
     with_config(:agent_enabled => true) do
-      @agent = NewRelic::Agent::ShimAgent.instance
-      @agent.shutdown
-      assert (not @agent.started?)
-      @agent.start
-      assert !@agent.started?
+      shim_agent = NewRelic::Agent::ShimAgent.instance
+      shim_agent.shutdown
+      refute shim_agent.started?
+      shim_agent.start
+      refute shim_agent.started?
+    end
+  end
 
-      # this installs the real agent:
+  def test_startup_shutdown_real
+    with_config(:agent_enabled => true, :monitor_mode => true) do
       NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
-      @agent = NewRelic::Agent.instance
-      assert @agent != NewRelic::Agent::ShimAgent.instance
-      assert @agent.started?
-      @agent.shutdown
-      assert !@agent.started?
-      NewRelic::Agent.shutdown
+      agent = NewRelic::Agent.instance
+      assert agent.started?
+      agent.shutdown
+      refute agent.started?
     end
   end
 
@@ -89,15 +89,15 @@ class NewRelic::Agent::RpmAgentTest < Minitest::Test
 
   def test_set_record_sql
     @agent.set_record_sql(false)
-    assert !NewRelic::Agent.is_sql_recorded?
+    assert !NewRelic::Agent.tl_is_sql_recorded?
     NewRelic::Agent.disable_sql_recording do
-      assert_equal false, NewRelic::Agent.is_sql_recorded?
+      assert_equal false, NewRelic::Agent.tl_is_sql_recorded?
       NewRelic::Agent.disable_sql_recording do
-        assert_equal false, NewRelic::Agent.is_sql_recorded?
+        assert_equal false, NewRelic::Agent.tl_is_sql_recorded?
       end
-      assert_equal false, NewRelic::Agent.is_sql_recorded?
+      assert_equal false, NewRelic::Agent.tl_is_sql_recorded?
     end
-    assert !NewRelic::Agent.is_sql_recorded?
+    assert !NewRelic::Agent.tl_is_sql_recorded?
     @agent.set_record_sql(nil)
   end
 
@@ -105,12 +105,6 @@ class NewRelic::Agent::RpmAgentTest < Minitest::Test
     assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
   end
 
-  def test_record_transaction_should_reject_empty_arguments
-    assert_raises RuntimeError do
-      NewRelic::Agent.record_transaction 0.5
-    end
-  end
-
   def test_record_transaction
     NewRelic::Agent.record_transaction 0.5, 'uri' => "/users/create?foo=bar"
   end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -10,11 +10,17 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     agent = NewRelic::Agent.instance
     stats_engine = NewRelic::Agent::StatsEngine.new
     agent.stubs(:stats_engine).returns(stats_engine)
+    @state = NewRelic::Agent::TransactionState.tl_get
+    @state.reset
     @sampler = NewRelic::Agent::SqlSampler.new
     @connection = stub('ActiveRecord connection', :execute => 'result')
     NewRelic::Agent::Database.stubs(:get_connection).returns(@connection)
   end
 
+  def teardown
+    @state.reset
+  end
+
   # Helpers for DataContainerTests
 
   def create_container
@@ -23,9 +29,9 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   def populate_container(sampler, n)
     n.times do |i|
-      sampler.on_start_transaction nil
-      sampler.notice_sql("SELECT * FROM test#{i}", "Database/test/select", nil, 1)
-      sampler.on_finishing_transaction('txn')
+      sampler.on_start_transaction(@state, nil)
+      sampler.notice_sql("SELECT * FROM test#{i}", "Database/test/select", nil, 1, @state)
+      sampler.on_finishing_transaction(@state, 'txn')
     end
   end
 
@@ -34,38 +40,40 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
   # Tests
 
   def test_on_start_transaction
-    assert_nil @sampler.transaction_data
-    @sampler.on_start_transaction nil
-    refute_nil @sampler.transaction_data
-    @sampler.on_finishing_transaction('txn')
-    assert_nil @sampler.transaction_data
+    assert_nil @sampler.tl_transaction_data
+    @sampler.on_start_transaction(@state, nil)
+    refute_nil @sampler.tl_transaction_data
+    @sampler.on_finishing_transaction(@state, 'txn')
+
+    # Transaction clearing cleans this @state for us--we don't do it ourselves
+    refute_nil @sampler.tl_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
+    assert_nil @sampler.tl_transaction_data
+    @sampler.notice_sql("select * from test", "Database/test/select", nil, 10, @state)
   end
 
   def test_notice_sql
-    @sampler.on_start_transaction 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
+    @sampler.on_start_transaction(@state, nil)
+    @sampler.notice_sql("select * from test", "Database/test/select", nil, 1.5, @state)
+    @sampler.notice_sql("select * from test2", "Database/test2/select", nil, 1.3, @state)
     # this sql will not be captured
-    @sampler.notice_sql "select * from test", "Database/test/select", nil, 0
-    refute_nil @sampler.transaction_data
-    assert_equal 2, @sampler.transaction_data.sql_data.size
+    @sampler.notice_sql("select * from test", "Database/test/select", nil, 0, @state)
+    refute_nil @sampler.tl_transaction_data
+    assert_equal 2, @sampler.tl_transaction_data.sql_data.size
   end
 
   def test_notice_sql_truncates_query
-    @sampler.on_start_transaction nil
+    @sampler.on_start_transaction(@state, 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)
+    @sampler.notice_sql(message, "Database/test/select", nil, 1.5, @state)
+    assert_equal('a' * 16_381 + '...', @sampler.tl_transaction_data.sql_data[0].sql)
   end
 
   def test_harvest_slow_sql
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("/c/a", {}, 'guid')
+    data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
     data.sql_data.concat [
       NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
@@ -94,7 +102,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   def test_harvest
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("/c/a", {}, 'guid')
+    data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
     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),
@@ -107,7 +115,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   def test_harvest_should_not_take_more_than_10
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("/c/a", {}, 'guid')
+    data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
     15.times do |i|
       data.sql_data << NewRelic::Agent::SlowSql.new("select * from test#{(i+97).chr}",
@@ -123,7 +131,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   def test_harvest_should_aggregate_similar_queries
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("/c/a", {}, 'guid')
+    data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
     queries = [
                NewRelic::Agent::SlowSql.new("select  * from test where foo in (1, 2)  ", "Database/test/select", {}, 1.5),
@@ -144,7 +152,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
      .returns(dummy_mysql_explain_result({"header0" => 'bar0', "header1" => 'bar1', "header2" => 'bar2'}))
 
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("/c/a", {}, 'guid')
+    data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
     explainer = NewRelic::Agent::Instrumentation::ActiveRecord::EXPLAINER
     config = { :adapter => 'mysql' }
@@ -174,17 +182,17 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   def test_sql_trace_should_include_transaction_guid
     txn_sampler = NewRelic::Agent::TransactionSampler.new
-    txn_sampler.start_builder(Time.now)
-    @sampler.on_start_transaction(Time.now, 'a uri', {:some => :params})
+    txn_sampler.start_builder(@state, Time.now)
+    @sampler.on_start_transaction(@state, Time.now, 'a uri')
 
-    assert_equal(NewRelic::Agent.instance.transaction_sampler.builder.sample.guid,
-                 NewRelic::Agent.instance.sql_sampler.transaction_data.guid)
+    assert_equal(NewRelic::Agent.instance.transaction_sampler.tl_builder.sample.guid,
+                 NewRelic::Agent.instance.sql_sampler.tl_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("/c/a", {}, 'guid')
+      data.set_transaction_info("/c/a", 'guid')
       data.set_transaction_name("WebTransaction/Controller/c/a")
       queries = [
                  NewRelic::Agent::SlowSql.new("select * from test",
@@ -210,7 +218,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
   def test_sends_obfuscated_queries_when_configured
     with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
       data = NewRelic::Agent::TransactionSqlData.new
-      data.set_transaction_info("/c/a", {}, 'guid')
+      data.set_transaction_info("/c/a", 'guid')
       data.set_transaction_name("WebTransaction/Controller/c/a")
       data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test where foo = 'bar'",
                                                          "Database/test/select", {}, 1.5),
@@ -241,7 +249,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
   def test_to_collector_array
     with_config(:'transaction_tracer.explain_enabled' => false) do
       data = NewRelic::Agent::TransactionSqlData.new
-      data.set_transaction_info("/c/a", {}, 'guid')
+      data.set_transaction_info("/c/a", 'guid')
       data.set_transaction_name("WebTransaction/Controller/c/a")
       data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test",
                                                          "Database/test/select",

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

@@ -18,6 +18,191 @@ class NewRelic::Agent::MetricStatsTest < Minitest::Test
     super
   end
 
+  def test_record_unscoped_metrics_records_to_transaction_stats_if_in_txn
+    in_transaction do
+      @engine.tl_record_unscoped_metrics(['a', 'b'], 20, 10)
+
+      # txn is still active, so metrics should not be merged into global
+      # stats hash yet
+      assert_metrics_not_recorded(['a', 'b'])
+    end
+
+    expected = {
+      :call_count           => 1,
+      :total_call_time      => 20,
+      :total_exclusive_time => 10
+    }
+    assert_metrics_recorded(
+      'a' => expected,
+      'b' => expected
+    )
+  end
+
+  def test_record_unscoped_metrics_records_to_global_metrics_if_no_txn
+    @engine.tl_record_unscoped_metrics(['a', 'b'], 20, 10)
+    expected = {
+      :call_count           => 1,
+      :total_call_time      => 20,
+      :total_exclusive_time => 10
+    }
+    assert_metrics_recorded(
+      'a' => expected,
+      'b' => expected
+    )
+  end
+
+  def test_record_unscoped_metrics_takes_single_metric_name
+    @engine.tl_record_unscoped_metrics('a', 20)
+    assert_metrics_recorded(
+      'a' => {
+        :call_count           => 1,
+        :total_call_time      => 20,
+        :total_exclusive_time => 20
+      }
+    )
+  end
+
+  def test_record_unscoped_metrics_takes_block_in_txn
+    in_transaction('txn') do
+      @engine.tl_record_unscoped_metrics('a') do |stat|
+        stat.total_call_time = 42
+        stat.call_count = 99
+      end
+    end
+
+    expected = { :total_call_time => 42, :call_count => 99 }
+    assert_metrics_recorded('a' => expected)
+  end
+
+  def test_record_unscoped_metrics_takes_block_outside_txn
+    @engine.tl_record_unscoped_metrics('a') do |stat|
+      stat.total_call_time = 42
+      stat.call_count = 99
+    end
+
+    expected = { :total_call_time => 42, :call_count => 99 }
+    assert_metrics_recorded('a' => expected)
+  end
+
+  def test_record_unscoped_metrics_is_thread_safe
+    threads = []
+    nthreads = 25
+    iterations = 100
+
+    nthreads.times do |tid|
+      threads << Thread.new do
+        iterations.times do
+          @engine.tl_record_unscoped_metrics('m1', 1)
+          @engine.tl_record_unscoped_metrics('m2', 1)
+        end
+      end
+    end
+    threads.each { |t| t.join }
+
+    assert_metrics_recorded(
+      'm1' => { :call_count => nthreads * iterations },
+      'm2' => { :call_count => nthreads * iterations }
+    )
+  end
+
+  def test_record_scoped_and_unscoped_metrics_records_scoped_and_unscoped
+    in_transaction('txn') do
+      @engine.tl_record_scoped_and_unscoped_metrics('a', nil, 20, 10)
+      assert_metrics_not_recorded('a')
+    end
+
+    expected = {
+      :call_count           => 1,
+      :total_call_time      => 20,
+      :total_exclusive_time => 10
+    }
+    assert_metrics_recorded(
+      'a'          => expected,
+      ['a', 'txn'] => expected
+    )
+  end
+
+  def test_record_scoped_and_unscoped_metrics_takes_block
+    in_transaction('txn') do
+      @engine.tl_record_scoped_and_unscoped_metrics('a', ['b']) do |stat|
+        stat.total_call_time = 42
+        stat.call_count = 99
+      end
+    end
+
+    expected = { :total_call_time => 42, :call_count => 99 }
+    assert_metrics_recorded(
+      'a'          => expected,
+      ['a', 'txn'] => expected,
+      'b'          => expected
+    )
+  end
+
+  def test_record_scoped_and_unscoped_metrics_records_multiple_unscoped_metrics
+    in_transaction('txn') do
+      @engine.tl_record_scoped_and_unscoped_metrics('a', ['b', 'c'], 20, 10)
+      assert_metrics_not_recorded(['a', 'b', 'c'])
+    end
+
+    expected = {
+      :call_count           => 1,
+      :total_call_time      => 20,
+      :total_exclusive_time => 10
+    }
+    assert_metrics_recorded(
+      'a'          => expected,
+      ['a', 'txn'] => expected,
+      'b'          => expected,
+      'c'          => expected
+    )
+    assert_metrics_not_recorded([
+      ['b', 'txn'],
+      ['c', 'txn']
+    ])
+  end
+
+  def test_record_scoped_and_unscoped_metrics_is_thread_safe
+    threads = []
+    nthreads = 25
+    iterations = 100
+
+    nthreads.times do |tid|
+      threads << Thread.new do
+        iterations.times do
+          in_transaction('txn') do
+            @engine.tl_record_scoped_and_unscoped_metrics('m1', ['m3'], 1)
+            @engine.tl_record_scoped_and_unscoped_metrics('m2', ['m4'], 1)
+          end
+        end
+      end
+    end
+    threads.each { |t| t.join }
+
+    expected = { :call_count => nthreads * iterations }
+    assert_metrics_recorded(
+      'm1'          => expected,
+      'm2'          => expected,
+      ['m1', 'txn'] => expected,
+      ['m2', 'txn'] => expected,
+      'm3'          => expected,
+      'm4'          => expected
+    )
+  end
+
+  def test_record_scoped_and_unscoped_metrics_records_unscoped_if_not_in_txn
+    @engine.tl_record_scoped_and_unscoped_metrics('a', ['b'], 20, 10)
+
+    expected = {
+      :call_count           => 1,
+      :total_call_time      => 20,
+      :total_exclusive_time => 10
+    }
+    assert_metrics_recorded_exclusive(
+      'a' => expected,
+      'b' => expected
+    )
+  end
+
   def test_get_no_scope
     s1 = @engine.get_stats "a"
     s2 = @engine.get_stats "a"
@@ -142,130 +327,17 @@ class NewRelic::Agent::MetricStatsTest < Minitest::Test
     assert_equal(t0, result.harvested_at)
   end
 
-  def test_record_metrics_unscoped_metrics_only_by_default
+  def test_record_unscoped_metrics_unscoped_metrics_only
     in_transaction('scopey') do
-      @engine.record_metrics('foo', 42)
+      @engine.tl_record_unscoped_metrics('foo', 42)
     end
     assert_metrics_recorded('foo' => { :call_count => 1, :total_call_time => 42 })
     assert_metrics_not_recorded([['foo', 'scopey']])
   end
 
-  def test_record_metrics_records_to_scoped_metric_if_requested
-    in_transaction('scopey') do
-      @engine.record_metrics('foo', 42, :scoped => true)
-    end
-    unscoped_stats = @engine.get_stats('foo', false)
-    scoped_stats = @engine.get_stats('foo', true, true, 'scopey')
-    assert_equal(1, unscoped_stats.call_count, 'missing unscoped metric')
-    assert_equal(1, scoped_stats.call_count, 'missing scoped metric')
-  end
-
-  def test_record_metrics_elides_scoped_metric_if_not_in_transaction
-    @engine.clear_stats
-    @engine.record_metrics('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_metrics_accepts_block
-    @engine.record_metrics('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_metrics_is_thread_safe
-    threads = []
-    nthreads = 25
-    iterations = 100
-    nthreads.times do |tid|
-      threads << Thread.new do
-        iterations.times do
-          @engine.record_metrics('m1', 1)
-          @engine.record_metrics('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
-
-  def test_record_metrics_internal_writes_to_global_stats_hash_if_no_txn
-    specs = [
-      NewRelic::MetricSpec.new('foo'),
-      NewRelic::MetricSpec.new('foo', 'scope')
-    ]
-
-    2.times { @engine.record_metrics_internal(specs, 10, 5) }
-
-    expected = { :call_count => 2, :total_call_time => 20, :total_exclusive_time => 10 }
-    assert_metrics_recorded('foo' => expected, ['foo', 'scope'] => expected)
-  end
-
-  def test_record_metrics_internal_writes_to_transaction_stats_hash_if_txn
-    specs = [
-      NewRelic::MetricSpec.new('foo'),
-      NewRelic::MetricSpec.new('foo', 'scope')
-    ]
-
-    in_transaction do
-      2.times { @engine.record_metrics_internal(specs, 10, 5) }
-      # still in the txn, so metrics should not be visible in the global stats
-      # hash yet
-      assert_metrics_not_recorded(['foo', ['foo, scope']])
-    end
-
-    expected = { :call_count => 2, :total_call_time => 20, :total_exclusive_time => 10 }
-    assert_metrics_recorded('foo' => expected, ['foo', 'scope'] => expected)
-  end
-
-  def test_transaction_stats_are_tracked_separately
-    in_transaction do
-      @engine.record_metrics('foo', 1)
-      assert_nil @engine.lookup_stats('foo')
-    end
-
-    assert_equal 1, @engine.lookup_stats('foo').call_count
-  end
-
-  def test_record_supportability_metric_timed_records_duration_of_block
-    freeze_time
-    2.times do
-      @engine.record_supportability_metric_timed('foo/bar') { advance_time(2.0) }
-    end
-
-    assert_metrics_recorded(['Supportability/foo/bar'] => {
-      :call_count => 2,
-      :total_call_time => 4.0
-    })
-  end
-
-  def test_record_supportability_metric_timed_does_not_break_when_block_raises
-    begin
-      freeze_time
-      @engine.record_supportability_metric_timed('foo/bar') do
-        advance_time(2.0)
-        1 / 0
-      end
-    rescue ZeroDivisionError
-      nil
-    end
-
-    assert_metrics_recorded(['Supportability/foo/bar'] => {
-      :call_count => 1,
-      :total_call_time => 2.0
-    })
-  end
-
   def test_record_supportability_metric_count_records_counts_only
-    @engine.record_supportability_metric_count('foo/bar', 1)
-    @engine.record_supportability_metric_count('foo/bar', 42)
+    @engine.tl_record_supportability_metric_count('foo/bar',  1)
+    @engine.tl_record_supportability_metric_count('foo/bar', 42)
     assert_metrics_recorded(['Supportability/foo/bar'] => {
       :call_count => 42,
       :total_call_time => 0