newrelic_rpm 3.6.6.147 → 3.6.7.152

data/test/new_relic/agent/threading/threaded_test_case.rb

@@ -0,0 +1,33 @@
+# 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.
+
+require 'new_relic/agent/threading/fake_thread'
+
+class ThreadedTestCase < Test::Unit::TestCase
+  def setup
+    @original_thread_class = NewRelic::Agent::Threading::AgentThread
+    swap_thread_class(FakeThread)
+  end
+
+  def teardown
+    swap_thread_class(@original_thread_class)
+    @original_thread_class = nil
+
+    FakeThread.list.clear
+  end
+
+  def default_test
+    # no-op to keep quiet....
+  end
+
+  private
+
+  def swap_thread_class(klass)
+    if NewRelic::Agent::Threading.const_defined?("AgentThread")
+      NewRelic::Agent::Threading.send(:remove_const, "AgentThread")
+    end
+    NewRelic::Agent::Threading.const_set("AgentThread", klass)
+  end
+end
+

data/test/new_relic/agent/transaction/pop_test.rb

@@ -18,10 +18,6 @@ class NewRelic::Agent::Transaction::PopTest < Test::Unit::TestCase
     @sql_sampler = mock('sql sampler')
   end
 
-  def teardown
-    Thread.current[:newrelic_transaction] = nil
-  end
-
   def test_log_underflow
     expects_logging(:error, regexp_matches(/Underflow in transaction: /))
     log_underflow
@@ -52,13 +48,6 @@ class NewRelic::Agent::Transaction::PopTest < Test::Unit::TestCase
     assert_equal nil, normal_cpu_burn
   end
 
-  # def test_jruby_cpu_burn_positive
-  #   @jruby_cpu_start = 3
-  #   self.expects(:jruby_cpu_time).returns(4)
-  #   self.expects(:record_jruby_cpu_burn).with(1)
-  #   assert_equal 1, jruby_cpu_burn
-  # end
-
   def test_jruby_cpu_burn_negative
     @jruby_cpu_start = nil
     self.expects(:jruby_cpu_time).never
@@ -83,11 +72,6 @@ class NewRelic::Agent::Transaction::PopTest < Test::Unit::TestCase
     assert_equal 2, cpu_burn
   end
 
-  def test_traced
-    NewRelic::Agent.expects(:is_execution_traced?)
-    traced?
-  end
-
   def test_current_stack_metric
     self.expects(:metric_name)
     current_stack_metric

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -220,10 +220,10 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
   end
 
   def test_finish_trace_records_threshold
-    NewRelic::Agent::TransactionInfo.get.stubs(:transaction_trace_threshold) \
-      .returns(2.0)
-    @builder.finish_trace
-    assert_equal 2.0, @builder.sample.threshold
+    with_config(:'transaction_tracer.transaction_threshold' => 2.0) do
+      @builder.finish_trace
+      assert_equal 2.0, @builder.sample.threshold
+    end
   end
 
   # regression
@@ -234,6 +234,25 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
     end
   end
 
+  def test_has_correct_transaction_trace_threshold_when_default
+    NewRelic::Agent::TransactionState.get.transaction = stub()
+    NewRelic::Agent::TransactionState.get.transaction.stubs(:apdex_t).returns(1.5)
+    assert_equal 6.0, @builder.transaction_trace_threshold
+
+    NewRelic::Agent::TransactionState.get.transaction.stubs(:apdex_t).returns(2.0)
+    assert_equal 8.0, @builder.transaction_trace_threshold
+  end
+
+  def test_has_correct_transaction_trace_threshold_when_explicitly_specified
+    config = { :'transaction_tracer.transaction_threshold' => 4.0 }
+
+    with_config(config, :do_not_cast => true) do
+      NewRelic::Agent::TransactionState.get.transaction = stub()
+      NewRelic::Agent::TransactionState.get.transaction.stubs(:apdex_t).returns(1.5)
+      assert_equal 4.0, @builder.transaction_trace_threshold
+    end
+  end
+
   def validate_builder(check_names = true)
     validate_segment @builder.sample.root_segment, check_names
   end

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -25,7 +25,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def setup
-    Thread::current[:record_sql] = nil
+    NewRelic::Agent::TransactionState.clear
     agent = NewRelic::Agent.instance
     stats_engine = NewRelic::Agent::StatsEngine.new
     agent.stubs(:stats_engine).returns(stats_engine)
@@ -40,7 +40,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   def teardown
     super
-    Thread.current[:transaction_sample_builder] = nil
+    NewRelic::Agent::TransactionState.clear
     NewRelic::Agent.config.remove_config(@test_config)
     NewRelic::Agent.instance.instance_variable_set(:@transaction_sampler, @old_sampler)
   end
@@ -420,13 +420,13 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_notice_sql_recording_sql
-    Thread.current[:record_sql] = true
+    NewRelic::Agent::TransactionState.get.record_sql = true
     @sampler.expects(:notice_extra_data).with('some sql', 1.0, :sql)
     @sampler.notice_sql('some sql', {:config => 'a config'}, 1.0)
   end
 
   def test_notice_sql_not_recording
-    Thread.current[:record_sql] = false
+    NewRelic::Agent::TransactionState.get.record_sql = false
     @sampler.expects(:notice_extra_data).with('some sql', 1.0, :sql).never # <--- important
     @sampler.notice_sql('some sql', {:config => 'a config'}, 1.0)
   end
@@ -597,42 +597,41 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_start_builder_default
-    Thread.current[:record_tt] = true
     NewRelic::Agent.expects(:is_execution_traced?).returns(true)
     @sampler.send(:start_builder)
-    assert(Thread.current[:transaction_sample_builder] \
+    assert(NewRelic::Agent::TransactionState.get.transaction_sample_builder \
              .is_a?(NewRelic::Agent::TransactionSampleBuilder),
            "should set up a new builder by default")
   end
 
   def test_start_builder_disabled
-    Thread.current[:transaction_sample_builder] = 'not nil.'
+    NewRelic::Agent::TransactionState.get.transaction_sample_builder = 'not nil.'
     with_config(:'transaction_tracer.enabled' => false,
                 :developer_mode => false) do
       @sampler.send(:start_builder)
-      assert_equal(nil, Thread.current[:transaction_sample_builder],
+      assert_equal(nil, NewRelic::Agent::TransactionState.get.transaction_sample_builder,
                    "should clear the transaction builder when disabled")
     end
   end
 
   def test_start_builder_dont_replace_existing_builder
     fake_builder = mock('transaction sample builder')
-    Thread.current[:transaction_sample_builder] = fake_builder
+    NewRelic::Agent::TransactionState.get.transaction_sample_builder = fake_builder
     @sampler.send(:start_builder)
-    assert_equal(fake_builder, Thread.current[:transaction_sample_builder],
+    assert_equal(fake_builder, NewRelic::Agent::TransactionState.get.transaction_sample_builder,
                  "should not overwrite an existing transaction sample builder")
-    Thread.current[:transaction_sample_builder] = nil
+    NewRelic::Agent::TransactionState.get.transaction_sample_builder = nil
   end
 
   def test_builder
-    Thread.current[:transaction_sample_builder] = 'shamalamadingdong, brother.'
+    NewRelic::Agent::TransactionState.get.transaction_sample_builder = 'shamalamadingdong, brother.'
     assert_equal('shamalamadingdong, brother.', @sampler.send(:builder),
                  'should return the value from the thread local variable')
-    Thread.current[:transaction_sample_builder] = nil
+    NewRelic::Agent::TransactionState.get.transaction_sample_builder = nil
   end
 
   def test_clear_builder
-    Thread.current[:transaction_sample_builder] = 'shamalamadingdong, brother.'
+    NewRelic::Agent::TransactionState.get.transaction_sample_builder = 'shamalamadingdong, brother.'
     assert_equal(nil, @sampler.send(:clear_builder), 'should clear the thread local variable')
   end
 
@@ -814,7 +813,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   def test_record_sql_off
     @sampler.notice_first_scope_push Time.now.to_f
 
-    Thread::current[:record_sql] = false
+    NewRelic::Agent::TransactionState.get.record_sql = false
 
     @sampler.notice_sql("test", {}, 0)
 

data/test/new_relic/agent/transaction_state_test.rb

@@ -0,0 +1,75 @@
+# 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.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/transaction'
+require 'new_relic/agent/transaction_state'
+
+module NewRelic::Agent
+  class TransactionStateTest < Test::Unit::TestCase
+    attr_reader :state
+
+    def setup
+      @state = TransactionState.new
+    end
+
+    def test_without_transaction_stack_on_thread
+      state.current_transaction_stack = nil
+      assert_equal false, state.in_background_transaction?
+      assert_equal false, state.in_request_transaction?
+    end
+
+    def test_in_background_transaction
+      state.current_transaction_stack = [NewRelic::Agent::Transaction.new]
+
+      assert state.in_background_transaction?
+    end
+
+    def test_in_request_tranasction
+      transaction = NewRelic::Agent::Transaction.new
+      transaction.request = stub()
+
+      state.current_transaction_stack = [transaction]
+
+      assert state.in_request_transaction?
+    end
+
+    def test_in_request_transaction_checks_last
+      earlier_transaction = NewRelic::Agent::Transaction.new
+      transaction = NewRelic::Agent::Transaction.new
+      transaction.request = stub()
+
+      state.current_transaction_stack = [earlier_transaction, transaction]
+
+      assert state.in_request_transaction?
+    end
+
+    def test_timings_without_transaction
+      freeze_time
+
+      state.reset(nil)
+      timings = state.timings
+
+      assert_equal 0.0, timings.queue_time_in_seconds
+      assert_equal 0.0, timings.app_time_in_seconds
+      assert_equal nil, timings.transaction_name
+    end
+
+    def test_timings_with_transaction
+      earliest_time = freeze_time
+      transaction = NewRelic::Agent::Transaction.new
+      transaction.apdex_start = earliest_time
+      transaction.start_time = earliest_time + 5
+      transaction.name = "Transaction/name"
+      state.transaction = transaction
+
+      advance_time(10.0)
+      timings = state.timings
+
+      assert_equal 5.0, timings.queue_time_in_seconds
+      assert_equal 5.0, timings.app_time_in_seconds
+      assert_equal transaction.name, timings.transaction_name
+    end
+  end
+end

data/test/new_relic/agent/transaction_test.rb

@@ -87,6 +87,21 @@ class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
     assert_equal(:apdex_f, bucket)
   end
 
+  def test_has_correct_apdex_t_for_transaction
+    config = {
+      :web_transactions_apdex => {'Controller/foo/bar' => 1.5},
+      :apdex_t => 2.0
+    }
+
+    with_config(config, :do_not_cast => true) do
+      txn.name = 'Controller/foo/bar'
+      assert_equal 1.5, txn.apdex_t
+
+      txn.name = 'Controller/some/other'
+      assert_equal 2.0, txn.apdex_t
+    end
+  end
+
   def test_update_apdex_records_correct_apdex_for_key_transaction
     config = {
       :web_transactions_apdex => {

data/test/new_relic/agent/transaction_timings_test.rb

@@ -0,0 +1,81 @@
+# 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.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/transaction_timings'
+
+module NewRelic::Agent
+  class TransactionTimingsTest < Test::Unit::TestCase
+
+    def setup
+      @start_time = freeze_time
+      @name = "Name"
+    end
+
+    def test_queue_time_nil
+      t = TransactionTimings.new(nil, @start_time, @name)
+      assert_equal 0.0, t.queue_time_in_millis
+    end
+
+    def test_queue_time_in_millis
+      t = TransactionTimings.new(1000.1234, @start_time, @name)
+      assert_equal 1_000_123, t.queue_time_in_millis
+    end
+
+    def test_queue_time_in_seconds
+      t = TransactionTimings.new(1000.1234, @start_time, @name)
+      assert_equal 1_000.1234, t.queue_time_in_seconds
+    end
+
+    def test_queue_time_clamps_to_positive_in_millis
+      t = TransactionTimings.new(-1000, @start_time, @name)
+      assert_equal 0, t.queue_time_in_millis
+    end
+
+    def test_queue_time_clamps_to_positive_in_seconds
+      t = TransactionTimings.new(-1000, @start_time, @name)
+      assert_equal 0, t.queue_time_in_seconds
+    end
+
+    def test_screwy_queue_time_defaults_to_zero
+      t = TransactionTimings.new("a duck", @start_time, @name)
+      assert_equal 0.0, t.queue_time_in_seconds
+    end
+
+    def test_app_time_in_millis
+      advance_time(2)
+      t = TransactionTimings.new(nil, @start_time, @name)
+      assert_equal 2_000.0, t.app_time_in_millis
+    end
+
+    def test_app_time_in_seconds
+      advance_time(2)
+      t = TransactionTimings.new(nil, @start_time, @name)
+      assert_equal 2.0, t.app_time_in_seconds
+    end
+
+    def test_locks_time_at_instantiation
+      t = TransactionTimings.new(1000, @start_time, @name)
+      original = t.app_time_in_seconds
+
+      advance_time(3)
+      later = t.app_time_in_seconds
+
+      assert_equal original, later
+    end
+
+    def test_transaction_name
+      t = TransactionTimings.new(nil, nil, @name)
+      assert_equal "Name", t.transaction_name
+    end
+
+    def test_clamp_to_positive
+      t = TransactionTimings.new(nil, nil, nil)
+      assert_equal(0.0, t.clamp_to_positive(-1), "should clamp a negative value to zero")
+      assert_equal(1232, t.clamp_to_positive(1232), "should pass through the value when it is positive")
+      assert_equal(0, t.clamp_to_positive(0), "should not mess with zero when passing it through")
+    end
+
+  end
+end

data/test/new_relic/agent_test.rb

@@ -19,7 +19,7 @@ module NewRelic
 
     def teardown
       super
-      Thread.current[:newrelic_untraced] = nil
+      NewRelic::Agent::TransactionState.clear
     end
 
     def test_shutdown
@@ -83,10 +83,8 @@ module NewRelic
     end
 
     def test_manual_start_starts_channel_listener
-      NewRelic::Agent::PipeChannelManager.listener.stop
+      NewRelic::Agent::PipeChannelManager.listener.expects(:start).at_least_once
       NewRelic::Agent.manual_start(:start_channel_listener => true)
-      assert NewRelic::Agent::PipeChannelManager.listener.started?
-      NewRelic::Agent::PipeChannelManager.listener.stop
       NewRelic::Agent.shutdown
     end
 
@@ -141,52 +139,52 @@ module NewRelic
     end
 
     def test_is_transaction_traced_true
-      Thread.current[:record_tt] = true
+      NewRelic::Agent::TransactionState.get.record_tt = true
       assert_equal(true, NewRelic::Agent.is_transaction_traced?, 'should be true since the thread local is set')
     end
 
     def test_is_transaction_traced_blank
-      Thread.current[:record_tt] = nil
+      NewRelic::Agent::TransactionState.get.record_tt = nil
       assert_equal(true, NewRelic::Agent.is_transaction_traced?, 'should be true since the thread local is not set')
     end
 
     def test_is_transaction_traced_false
-      Thread.current[:record_tt] = false
+      NewRelic::Agent::TransactionState.get.record_tt = false
       assert_equal(false, NewRelic::Agent.is_transaction_traced?, 'should be false since the thread local is false')
     end
 
     def test_is_sql_recorded_true
-      Thread.current[:record_sql] = true
+      NewRelic::Agent::TransactionState.get.record_sql = true
       assert_equal(true, NewRelic::Agent.is_sql_recorded?, 'should be true since the thread local is set')
     end
 
     def test_is_sql_recorded_blank
-      Thread.current[:record_sql] = nil
+      NewRelic::Agent::TransactionState.get.record_sql = nil
       assert_equal(true, NewRelic::Agent.is_sql_recorded?, 'should be true since the thread local is not set')
     end
 
     def test_is_sql_recorded_false
-      Thread.current[:record_sql] = false
+      NewRelic::Agent::TransactionState.get.record_sql = false
       assert_equal(false, NewRelic::Agent.is_sql_recorded?, 'should be false since the thread local is false')
     end
 
     def test_is_execution_traced_true
-      Thread.current[:newrelic_untraced] = [true, true]
+      NewRelic::Agent::TransactionState.get.untraced = [true, true]
       assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is set')
     end
 
     def test_is_execution_traced_blank
-      Thread.current[:newrelic_untraced] = nil
+      NewRelic::Agent::TransactionState.get.untraced = nil
       assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is not set')
     end
 
     def test_is_execution_traced_empty
-      Thread.current[:newrelic_untraced] = []
+      NewRelic::Agent::TransactionState.get.untraced = []
       assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is an empty array')
     end
 
     def test_is_execution_traced_false
-      Thread.current[:newrelic_untraced] = [true, false]
+      NewRelic::Agent::TransactionState.get.untraced = [true, false]
       assert_equal(false, NewRelic::Agent.is_execution_traced?, 'should be false since the thread local stack has the last element false')
     end