newrelic_rpm 3.8.1.221 → 3.9.0.229

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

@@ -28,7 +28,9 @@ class NewRelic::Agent::Instrumentation::SinatraTest < Minitest::Test
     expected_headers = {:fake => :header}
     @app.request = mock('request', :env => expected_headers)
 
-    assert_equal @app.newrelic_request_headers, expected_headers
+    state = NewRelic::Agent::TransactionState.tl_get
+
+    assert_equal(@app.newrelic_request_headers(state), expected_headers)
   end
 
   def test_process_route_with_bad_arguments

data/test/new_relic/agent/javascript_instrumentor_test.rb

@@ -18,19 +18,19 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
       :license_key            => "\0",  # no-op obfuscation key
       :'rum.enabled'          => true
     }
-    NewRelic::Agent.config.apply_config(@config)
+    NewRelic::Agent.config.add_config_for_testing(@config)
 
     events = stub(:subscribe => nil)
     @instrumentor = NewRelic::Agent::JavascriptInstrumentor.new(events)
 
     # By default we expect our transaction to have a start time
     # All sorts of basics don't output without this setup initially
-    NewRelic::Agent::TransactionState.reset
+    NewRelic::Agent::TransactionState.tl_get.reset
   end
 
   def teardown
-    NewRelic::Agent::TransactionState.clear
-    NewRelic::Agent.config.remove_config(@config)
+    NewRelic::Agent::TransactionState.tl_clear_for_testing
+    NewRelic::Agent.config.reset_to_defaults
   end
 
   def test_js_errors_beta_default_gets_default_loader
@@ -53,27 +53,6 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
     assert NewRelic::Agent.config[:'browser_monitoring.auto_instrument']
   end
 
-  def test_start_time_reset_each_request_when_auto_instrument_is_disabled
-    controller = Object.new
-    def controller.perform_action_without_newrelic_trace(method, options={});
-      # noop; instrument me
-    end
-    def controller.newrelic_metric_path; "foo"; end
-    controller.extend ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-    with_config(:'browser_monitoring.auto_instrument' => false) do
-      controller.perform_action_with_newrelic_trace(:index)
-      first_request_start_time = instrumentor.current_transaction.start_time
-
-      controller.perform_action_with_newrelic_trace(:index)
-      second_request_start_time = instrumentor.current_transaction.start_time
-
-      # assert that these aren't the same time object
-      # the start time should be reinitialized each request to the controller
-      assert !(first_request_start_time.equal? second_request_start_time)
-    end
-  end
-
   def test_browser_timing_header_outside_transaction
     assert_equal "", instrumentor.browser_timing_header
   end
@@ -127,8 +106,8 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
   end
 
   def test_browser_timing_header_with_ignored_enduser
-    in_transaction do
-      NewRelic::Agent::TransactionState.get.request_ignore_enduser = true
+    in_transaction do |txn|
+      txn.ignore_enduser!
       assert_equal "", instrumentor.browser_timing_header
     end
   end
@@ -144,12 +123,15 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
 
   def test_browser_timing_header_safe_when_insert_js_fails
     in_transaction do
-      NewRelic::Agent.stubs(:config).raises("Hahahaha")
-      assert_equal "", instrumentor.browser_timing_header
+      begin
+        NewRelic::Agent.stubs(:config).raises("Hahahaha")
+        assert_equal "", instrumentor.browser_timing_header
+      ensure
+        # stopping the transaction touches config, so we need to ensure we
+        # clean up after ourselves here.
+        NewRelic::Agent.unstub(:config)
+      end
     end
-  ensure
-    # Teardown touches config, so make sure we're clean before we bail here
-    NewRelic::Agent.unstub(:config)
   end
 
   def test_browser_timing_header_safe_when_loader_generation_fails
@@ -172,15 +154,15 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
       with_config(CAPTURE_ATTRIBUTES => true) do
         NewRelic::Agent.set_user_attributes(:user => "user")
 
-        txn = NewRelic::Agent::Transaction.current
+        txn = NewRelic::Agent::Transaction.tl_current
         txn.stubs(:queue_time).returns(0)
         txn.stubs(:start_time).returns(Time.now - 10)
         txn.stubs(:guid).returns('ABC')
 
-        state = NewRelic::Agent::TransactionState.get
+        state = NewRelic::Agent::TransactionState.tl_get
         state.request_token = '0123456789ABCDEF'
 
-        data = instrumentor.data_for_js_agent
+        data = instrumentor.data_for_js_agent(state)
         expected = {
           "beacon"          => "beacon",
           "errorBeacon"     => "",
@@ -197,7 +179,7 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
 
         assert_equal(expected, data)
 
-        js = instrumentor.browser_timing_config
+        js = instrumentor.browser_timing_config(state)
         expected.each do |key, value|
           assert_match(/"#{key.to_s}":#{formatted_for_matching(value)}/, js)
         end
@@ -206,20 +188,23 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
   end
 
   def test_ssl_for_http_not_included_by_default
-    data = instrumentor.data_for_js_agent
+    state = NewRelic::Agent::TransactionState.tl_get
+    data = instrumentor.data_for_js_agent(state)
     assert_not_includes data, "sslForHttp"
   end
 
   def test_ssl_for_http_enabled
     with_config(:'browser_monitoring.ssl_for_http' => true) do
-      data = instrumentor.data_for_js_agent
+      state = NewRelic::Agent::TransactionState.tl_get
+      data = instrumentor.data_for_js_agent(state)
       assert data["sslForHttp"]
     end
   end
 
   def test_ssl_for_http_disabled
     with_config(:'browser_monitoring.ssl_for_http' => false) do
-      data = instrumentor.data_for_js_agent
+      state = NewRelic::Agent::TransactionState.tl_get
+      data = instrumentor.data_for_js_agent(state)
       assert_false data["sslForHttp"]
     end
   end
@@ -305,12 +290,14 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
   end
 
   def assert_user_attributes_are(expected)
-    data = instrumentor.data_for_js_agent
+    state = NewRelic::Agent::TransactionState.tl_get
+    data = instrumentor.data_for_js_agent(state)
     assert_equal pack(expected), data["userAttributes"]
   end
 
   def assert_user_attributes_missing
-    data = instrumentor.data_for_js_agent
+    state = NewRelic::Agent::TransactionState.tl_get
+    data = instrumentor.data_for_js_agent(state)
     assert_not_includes data, "userAttributes"
   end
 

data/test/new_relic/agent/memory_logger_test.rb

@@ -41,6 +41,20 @@ class MemoryLoggerTest < Minitest::Test
     @logger.dump(real_logger)
   end
 
+  def test_proxies_message_blocks
+    called = false
+    @logger.info do
+      called = true
+      'a'
+    end
+
+    real_logger = stub
+    real_logger.expects(:info).yields()
+
+    @logger.dump(real_logger)
+    assert called
+  end
+
   def test_proxies_through_calls_to_log_exception
     e = Exception.new
     @logger.log_exception(:fatal, e, :error)

data/test/new_relic/agent/method_interrobang_test.rb

@@ -24,7 +24,7 @@ class MethodInterrobangTest < Minitest::Test
 		assert_equal "say what?", interrogate?
 	end
 
-	def test_aliase_method_ending_in_exclamation_makr
+	def test_alias_method_ending_in_exclamation_mark
 		assert_respond_to self, :mutate!
 		assert_equal "oh yeah!", mutate!
 	end

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

@@ -22,7 +22,6 @@ module NewRelic
 
             def test_validate_options_defaults
               self.expects(:check_for_illegal_keys!)
-              self.expects(:set_deduct_call_time_based_on_metric).with(DEFAULT_SETTINGS)
               self.expects(:check_for_push_scope_and_metric)
               validate_options(:applejack, {})
             end
@@ -54,34 +53,6 @@ module NewRelic
               assert !self.class.newrelic_method_exists?('test_method')
             end
 
-            def test_set_deduct_call_time_based_on_metric_positive
-              opts = {:metric => true}
-              val = set_deduct_call_time_based_on_metric(opts)
-              assert val.is_a?(Hash)
-              assert val[:deduct_call_time_from_parent]
-            end
-
-            def test_set_deduct_call_time_based_on_metric_negative
-              opts = {:metric => false}
-              val = set_deduct_call_time_based_on_metric(opts)
-              assert val.is_a?(Hash)
-              assert !val[:deduct_call_time_from_parent]
-            end
-
-            def test_set_deduct_call_time_based_on_metric_non_nil
-              opts = {:deduct_call_time_from_parent => true, :metric => false}
-              val = set_deduct_call_time_based_on_metric(opts)
-              assert val.is_a?(Hash)
-              assert val[:deduct_call_time_from_parent]
-            end
-
-            def test_set_deduct_call_time_based_on_metric_opposite
-              opts = {:deduct_call_time_from_parent => false, :metric => true}
-              val = set_deduct_call_time_based_on_metric(opts)
-              assert val.is_a?(Hash)
-              assert !val[:deduct_call_time_from_parent]
-            end
-
             def test_check_for_illegal_keys_positive
               assert_raises(RuntimeError) do
                 check_for_illegal_keys!(:twilight_sparkle, {:unknown_key => nil})
@@ -118,7 +89,7 @@ module NewRelic
             def test_assemble_code_header_unforced
               self.expects(:_untraced_method_name).returns("method_name_without_tracing")
               opts = {:force => false, :code_header => 'CODE HEADER'}
-              assert_equal "return method_name_without_tracing(*args, &block) unless NewRelic::Agent.is_execution_traced?\nCODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
+              assert_equal "return method_name_without_tracing(*args, &block) unless NewRelic::Agent.tl_is_execution_traced?\nCODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
             end
 
             def test_check_for_push_scope_and_metric_positive

data/test/new_relic/agent/method_tracer/instance_methods/trace_execution_scoped_test.rb

@@ -136,22 +136,6 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
     )
   end
 
-  def test_metric_recording_with_scoped_metric_only_option
-    options = { :scoped_metric_only => true }
-
-    in_transaction('outer') do
-      trace_execution_scoped(['foo', 'bar'], options) do
-        # erm
-      end
-    end
-
-    expected_values = { :call_count => 1 }
-    assert_metrics_recorded_exclusive(
-      'outer'          => expected_values,
-      ['foo', 'outer'] => expected_values
-    )
-  end
-
   def test_set_if_nil
     h = {}
     set_if_nil(h, :foo)
@@ -191,10 +175,11 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
   end
 
   def test_trace_execution_scoped_header
-    options = {:force => false, :deduct_call_time_from_parent => false}
-    self.expects(:log_errors).with('trace_execution_scoped header').yields
-    NewRelic::Agent::TracedMethodStack.expects(:push_frame).with(:method_tracer, 1.0, false)
-    trace_execution_scoped_header(options, 1.0)
+    state = NewRelic::Agent::TransactionState.tl_get
+    stack = state.traced_method_stack
+    self.expects(:log_errors).with(:trace_execution_scoped_header).yields
+    stack.expects(:push_frame).with(state, :method_tracer, 1.0)
+    trace_execution_scoped_header(state, 1.0)
   end
 
   def test_trace_execution_scoped_calculates_exclusive_time
@@ -236,7 +221,6 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
   end
 
   def test_trace_execution_scoped_disabled
-    self.expects(:traced?).returns(false)
     # make sure the method doesn't beyond the abort
     self.expects(:set_if_nil).never
     ran = false

data/test/new_relic/agent/method_tracer_test.rb

@@ -62,7 +62,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
   attr_reader :stats_engine
 
   def setup
-    NewRelic::Agent::TransactionState.clear
+    NewRelic::Agent::TransactionState.tl_clear_for_testing
 
     NewRelic::Agent.manual_start
     @stats_engine = NewRelic::Agent.instance.stats_engine
@@ -93,7 +93,8 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
   end
 
   def test_record_metrics_does_not_raise_outside_transaction
-    NewRelic::Agent::MethodTracer::TraceExecutionScoped.record_metrics('a', ['b'], 12, 10, :metric => true)
+    state = NewRelic::Agent::TransactionState.tl_get
+    NewRelic::Agent::MethodTracer::TraceExecutionScoped.record_metrics(state, 'a', ['b'], 12, 10, :metric => true)
 
     expected = { :call_count => 1, :total_call_time => 12, :total_exclusive_time => 10 }
     assert_metrics_recorded('a' => expected, 'b' => expected)
@@ -179,8 +180,8 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
 
     stats = @stats_engine.get_stats("Custom/#{self.class.name}/simple_method")
     assert stats.call_count == 1
-
   end
+
   def test_add_method_tracer__reentry
     self.class.add_method_tracer :simple_method
     self.class.add_method_tracer :simple_method
@@ -352,7 +353,7 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     begin
       metric = "hey"
       self.class.trace_execution_scoped(metric) do
-        throw StandardError.new
+        raise StandardError.new
       end
 
       assert false # should never get here

data/test/new_relic/agent/mock_scope_listener.rb

@@ -11,10 +11,10 @@ class NewRelic::Agent::MockScopeListener
     @scopes = []
   end
 
-  def notice_push_frame(time)
+  def notice_push_frame(state, time)
   end
 
-  def notice_pop_frame(scope, time)
+  def notice_pop_frame(state, scope, time)
     @scopes << scope
   end
 

data/test/new_relic/agent/obfuscator_test.rb

@@ -12,7 +12,7 @@ class NewRelic::Agent::ObfuscatorTest < Minitest::Test
 
   def setup
     @config = { :license_key => OBFUSCATION_KEY }
-    NewRelic::Agent.config.apply_config(@config)
+    NewRelic::Agent.config.add_config_for_testing(@config)
   end
 
   def teardown

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -12,10 +12,10 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
   def setup
     @test_config = { :developer_mode => true }
     NewRelic::Agent.agent.drop_buffered_data
-    NewRelic::Agent.config.apply_config(@test_config)
+    NewRelic::Agent.config.add_config_for_testing(@test_config)
     NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
     NewRelic::Agent.manual_start
-    NewRelic::Agent::TransactionState.clear
+    NewRelic::Agent::TransactionState.tl_clear_for_testing
   end
 
   def teardown
@@ -161,6 +161,17 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
       listener.stop
     end
 
+    def test_manager_does_not_crash_when_given_unmarshallable_junk
+      listener = start_listener_with_pipe(671)
+      expects_logging(:error, any_parameters)
+
+      pid = Process.fork do
+        listener.pipes[671].write("\x00")
+      end
+      Process.wait(pid)
+      listener.stop
+    end
+
     def pipe_finished?(id)
       (!NewRelic::Agent::PipeChannelManager.channels[id] ||
         NewRelic::Agent::PipeChannelManager.channels[id].closed?)
@@ -172,9 +183,10 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
     end
 
     def create_sql_sample(sampler)
-      sampler.on_start_transaction(Time.now)
-      sampler.notice_sql("SELECT * FROM table", "ActiveRecord/Widgets/find", nil, 100)
-      sampler.on_finishing_transaction('noodles', Time.now)
+      state = NewRelic::Agent::TransactionState.tl_get
+      sampler.on_start_transaction(state, Time.now)
+      sampler.notice_sql("SELECT * FROM table", "ActiveRecord/Widgets/find", nil, 100, state)
+      sampler.on_finishing_transaction(state, 'noodles', Time.now)
     end
   end
 

data/test/new_relic/agent/request_sampler_test.rb

@@ -68,11 +68,11 @@ class NewRelic::Agent::RequestSamplerTest < Minitest::Test
 
   def test_custom_parameters_in_event_cant_override_reserved_attributes
     with_sampler_config do
-      metrics = NewRelic::Agent::StatsHash.new()
-      metrics.record(NewRelic::MetricSpec.new('HttpDispatcher'), 0.01)
+      metrics = NewRelic::Agent::TransactionMetrics.new()
+      metrics.record_unscoped('HttpDispatcher', 0.01)
 
       generate_request('whatever',
-        :metrics => metrics,
+        :metrics       => metrics,
         :custom_params => {'type' => 'giraffe', 'duration' => 'hippo'}
       )
       txn_event = single_sample[EVENT_DATA_INDEX]
@@ -86,15 +86,15 @@ class NewRelic::Agent::RequestSamplerTest < Minitest::Test
   end
 
   def test_samples_on_transaction_finished_event_includes_expected_web_metrics
-    stats_hash = NewRelic::Agent::StatsHash.new
-    stats_hash.record(NewRelic::MetricSpec.new('WebFrontend/QueueTime'), 13)
-    stats_hash.record(NewRelic::MetricSpec.new('External/allWeb'), 14)
-    stats_hash.record(NewRelic::MetricSpec.new('Datastore/all'), 15)
-    stats_hash.record(NewRelic::MetricSpec.new("GC/Transaction/all"), 16)
-    stats_hash.record(NewRelic::MetricSpec.new('Memcache/allWeb'), 17)
+    txn_metrics = NewRelic::Agent::TransactionMetrics.new
+    txn_metrics.record_unscoped('WebFrontend/QueueTime', 13)
+    txn_metrics.record_unscoped('External/allWeb',       14)
+    txn_metrics.record_unscoped('Datastore/all',         15)
+    txn_metrics.record_unscoped("GC/Transaction/all",    16)
+    txn_metrics.record_unscoped('Memcache/allWeb',       17)
 
     with_sampler_config do
-      generate_request('name', :metrics => stats_hash)
+      generate_request('name', :metrics => txn_metrics)
       event_data = single_sample[EVENT_DATA_INDEX]
       assert_equal 13, event_data["queueDuration"]
       assert_equal 14, event_data["externalDuration"]
@@ -108,14 +108,14 @@ class NewRelic::Agent::RequestSamplerTest < Minitest::Test
   end
 
   def test_samples_on_transaction_finished_includes_expected_background_metrics
-    stats_hash = NewRelic::Agent::StatsHash.new
-    stats_hash.record(NewRelic::MetricSpec.new('External/allOther'), 12)
-    stats_hash.record(NewRelic::MetricSpec.new('Datastore/all'), 13)
-    stats_hash.record(NewRelic::MetricSpec.new("GC/Transaction/all"), 14)
-    stats_hash.record(NewRelic::MetricSpec.new('Memcache/allOther'), 15)
+    txn_metrics = NewRelic::Agent::TransactionMetrics.new
+    txn_metrics.record_unscoped('External/allOther',  12)
+    txn_metrics.record_unscoped('Datastore/all',      13)
+    txn_metrics.record_unscoped("GC/Transaction/all", 14)
+    txn_metrics.record_unscoped('Memcache/allOther',  15)
 
     with_sampler_config do
-      generate_request('name', :metrics => stats_hash)
+      generate_request('name', :metrics => txn_metrics)
 
       event_data = single_sample[EVENT_DATA_INDEX]
       assert_equal 12, event_data["externalDuration"]