newrelic_rpm 3.8.1.221 → 3.9.0.229

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

@@ -111,7 +111,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Minitest::T
 
     in_transaction do
       simulate_query(2)
-      sql = sampler.transaction_data.sql_data[0].sql
+      sql = sampler.tl_transaction_data.sql_data[0].sql
     end
 
     assert_equal 'SELECT * FROM sandwiches', sql

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

@@ -19,7 +19,7 @@ class NewRelic::Agent::Instrumentation::NewActiveRecordInstrumentationTest < Min
 
   def teardown
     super
-    NewRelic::Agent::TransactionState.reset
+    NewRelic::Agent::TransactionState.tl_get.reset
     NewRelic::Agent.shutdown
   end
 
@@ -241,7 +241,7 @@ class NewRelic::Agent::Instrumentation::NewActiveRecordInstrumentationTest < Min
       ActiveRecordFixtures::Order.first
     end
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-    segment = find_segment_by_name(sample, 'ActiveRecord/ActiveRecordFixtures::Order/find')
+    segment = find_segment_with_name(sample, 'ActiveRecord/ActiveRecordFixtures::Order/find')
 
     assert_equal('ActiveRecord/ActiveRecordFixtures::Order/find', segment.metric_name)
 
@@ -260,7 +260,7 @@ class NewRelic::Agent::Instrumentation::NewActiveRecordInstrumentationTest < Min
       end
 
       sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-      sql_segment = find_segment_by_name(sample, 'ActiveRecord/ActiveRecordFixtures::Order/find')
+      sql_segment = find_segment_with_name(sample, 'ActiveRecord/ActiveRecordFixtures::Order/find')
 
       assert_match(/^SELECT /, sql_segment.params[:sql])
 

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

@@ -25,8 +25,7 @@ class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Minitest
     NewRelic::Agent.drop_buffered_data
     @object = TestObject.new
     @dummy_headers = { :request => 'headers' }
-    @txn_namer = NewRelic::Agent::Instrumentation:: \
-      ControllerInstrumentation::TransactionNamer.new(@object)
+    @txn_namer = NewRelic::Agent::Instrumentation::ControllerInstrumentation::TransactionNamer
   end
 
   def teardown
@@ -46,53 +45,67 @@ class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Minitest
 
   def test_transaction_name_calls_newrelic_metric_path
     @object.stubs(:newrelic_metric_path).returns('some/wacky/path')
-    assert_equal('Controller/some/wacky/path', @txn_namer.name)
+    assert_equal('Controller/some/wacky/path', @txn_namer.name(nil, @object, :controller))
   end
 
   def test_transaction_name_applies_category_and_path
     assert_equal('Controller/metric/path',
-                 @txn_namer.name(:category => :controller,
+                 @txn_namer.name(nil,
+                                 @object,
+                                 :controller,
                                  :path => 'metric/path'))
     assert_equal('OtherTransaction/Background/metric/path',
-                 @txn_namer.name(:category => :task,
+                 @txn_namer.name(nil,
+                                 @object,
+                                 :task,
                                  :path => 'metric/path'))
     assert_equal('Controller/Rack/metric/path',
-                 @txn_namer.name(:category => :rack,
+                 @txn_namer.name(nil,
+                                 @object,
+                                 :rack,
                                  :path => 'metric/path'))
     assert_equal('Controller/metric/path',
-                 @txn_namer.name(:category => :uri,
+                 @txn_namer.name(nil,
+                                 @object,
+                                 :uri,
                                  :path => 'metric/path'))
     assert_equal('Controller/Sinatra/metric/path',
-                 @txn_namer.name(:category => :sinatra,
+                 @txn_namer.name(nil,
+                                 @object,
+                                 :sinatra,
                                  :path => 'metric/path'))
     assert_equal('Blarg/metric/path',
-                 @txn_namer.name(:category => 'Blarg',
+                 @txn_namer.name(nil,
+                                 @object,
+                                 'Blarg',
                                  :path => 'metric/path'))
   end
 
   def test_transaction_name_uses_class_name_if_path_not_specified
     assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject',
-                 @txn_namer.name(:category => :controller))
+                 @txn_namer.name(nil, @object, :controller))
   end
 
   def test_transaction_name_applies_action_name_if_specified_and_not_path
     assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/action',
-                 @txn_namer.name(:category => :controller,
+                 @txn_namer.name(nil,
+                                 @object,
+                                 :controller,
                                  :name => 'action'))
   end
 
   def test_transaction_path_name
-    result = @txn_namer.path_name
+    result = @txn_namer.path_name(@object)
     assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject", result)
   end
 
   def test_transaction_path_name_with_name
-    result = @txn_namer.path_name(:name => "test")
+    result = @txn_namer.path_name(@object, :name => "test")
     assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/test", result)
   end
 
   def test_transaction_path_name_with_overridden_class_name
-    result = @txn_namer.path_name(:name => "perform", :class_name => 'Resque')
+    result = @txn_namer.path_name(@object, :name => "perform", :class_name => 'Resque')
     assert_equal("Resque/perform", result)
   end
 
@@ -138,4 +151,72 @@ class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Minitest
     with_method_name = 'public_transaction_with_newrelic_transaction_trace'
     assert TestObject.already_added_transaction_tracer?(TestObject, with_method_name)
   end
+
+  # ControllerInstrumentation historically was used to instrument Rails 2
+  # controllers, and in this case is called without a block. In that case, and
+  # that case *only*, we want to try to call params on the host object to
+  # extract request params.
+  #
+  # In the more modern usage where it's called with a block we do *not* want to
+  # call params on the host object. This is important because doing so could
+  # actually crash in some cases.
+  def test_should_not_call_params_on_host_if_called_with_block
+    host_class = Class.new do
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      # It's a more realistic test if the host class actually responds to params
+      def params
+        raise 'no!'
+      end
+
+      def doit
+        perform_action_with_newrelic_trace do
+          # nothing
+        end
+      end
+    end
+
+    host = host_class.new
+    host.expects(:params).never
+    host.doit
+  end
+
+  def test_should_not_call_params_on_host_if_no_block_given_but_does_not_respond_to_params
+    host_class = Class.new do
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      def doit
+        perform_action_with_newrelic_trace
+      end
+
+      def perform_action_without_newrelic_trace; end
+    end
+
+    host = host_class.new
+    refute host.respond_to?(:params)
+    host.doit
+  end
+
+  def test_should_call_params_on_host_if_no_block_given_and_host_responds
+    host_class = Class.new do
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      attr_reader :params_called
+
+      def params
+        @params_called = true
+        {}
+      end
+
+      def doit
+        perform_action_with_newrelic_trace
+      end
+
+      def perform_action_without_newrelic_trace; end
+    end
+
+    host = host_class.new
+    host.doit
+    assert host.params_called
+  end
 end

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

@@ -0,0 +1,189 @@
+# 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'))
+
+class NewRelic::Agent::Instrumentation::MiddlewareProxyTest < Minitest::Test
+
+  def setup
+    NewRelic::Agent.drop_buffered_data
+  end
+
+  def test_generator_creates_wrapped_instances
+    middleware_class = Class.new
+
+    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+    wrapped_instance  = generator.new
+
+    assert_kind_of(NewRelic::Agent::Instrumentation::MiddlewareProxy, wrapped_instance)
+    assert_kind_of(middleware_class, wrapped_instance.target)
+  end
+
+  def test_generator_passes_through_initialize_args
+    middleware_class = Class.new do
+      attr_reader :initialize_args
+
+      def initialize(*args)
+        @initialize_args = args
+      end
+    end
+
+    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+    wrapped_instance = generator.new('abc', 123)
+
+    assert_equal(['abc', 123], wrapped_instance.target.initialize_args)
+  end
+
+  def test_generator_passes_through_block_to_initialize
+    middleware_class = Class.new do
+      attr_reader :initialize_args
+
+      def initialize(*args, &blk)
+        @initialize_args = args
+        blk.call
+      end
+    end
+
+    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+
+    block_called = false
+    wrapped_instance = generator.new('abc', 123) do
+      block_called = true
+    end
+
+    assert block_called
+    assert_equal(['abc', 123], wrapped_instance.target.initialize_args)
+  end
+
+  def test_does_not_wrap_sinatra_apps
+    sinatra_dummy_module = Module.new
+    sinatra_dummy_class  = Class.new(Object)
+    app_class            = Class.new(sinatra_dummy_class)
+
+    with_constant_defined(:'::Sinatra', sinatra_dummy_module) do
+      with_constant_defined(:'::Sinatra::Base', sinatra_dummy_class) do
+        app = app_class.new
+
+        wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+
+        assert_same(app, wrapped)
+      end
+    end
+  end
+
+  def test_does_not_wrap_instrumented_middlewares
+    app_class = Class.new do
+      def _nr_has_middleware_tracing
+        true
+      end
+    end
+
+    app = app_class.new
+
+    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+
+    assert_same(app, wrapped)
+  end
+
+  def test_should_wrap_non_instrumented_middlewares
+    app_class = Class.new do
+      def call(env)
+        :yay
+      end
+    end
+
+    app = app_class.new
+
+    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+
+    assert_kind_of(NewRelic::Agent::Instrumentation::MiddlewareProxy, wrapped)
+  end
+
+  def test_call_should_proxy_to_target_when_in_transaction
+    call_was_called = false
+    call_received   = nil
+
+    app = lambda do |env|
+      call_was_called = true
+      call_received   = env
+      :super_duper
+    end
+
+    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+    env = {}
+
+    ret = nil
+    in_transaction do
+      ret = wrapped.call(env)
+    end
+
+    assert(call_was_called)
+    assert_equal(:super_duper, ret)
+    assert_same(env, call_received)
+  end
+
+  def test_call_should_proxy_to_target_when_not_in_transaction
+    call_was_called = false
+    call_received   = nil
+
+    app = lambda do |env|
+      call_was_called = true
+      call_received   = env
+      :super_duper
+    end
+
+    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+    env = {}
+    ret = wrapped.call(env)
+
+    assert(call_was_called)
+    assert_equal(:super_duper, ret)
+    assert_same(env, call_received)
+  end
+
+  def test_should_start_transaction_if_none_is_running
+    app = lambda do |env|
+      :super_duper
+    end
+
+    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+
+    wrapped.call({})
+
+    assert_metrics_recorded("HttpDispatcher")
+  end
+
+  def test_should_respect_force_transaction_flag
+    app = lambda do |env|
+      :super_duper
+    end
+
+    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+
+    in_transaction('Controller/foo', :category => :controller) do
+      wrapped.call({})
+    end
+
+    assert_metrics_recorded('Controller/Rack/Proc/call')
+  end
+
+  def test_should_get_the_right_name_when_target_is_a_class
+    target_class = Class.new do
+      def self.name
+        "GreatClass"
+      end
+
+      def self.call(env)
+        :super_duper
+      end
+    end
+
+    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(target_class, true)
+
+    wrapped.call({})
+
+    assert_metrics_recorded('Controller/Rack/GreatClass/call')
+  end
+end
+

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

@@ -24,9 +24,9 @@ class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Minitest::Test
   def test_scope_stack_integrity_maintained_on_request_failure
     @socket.stubs(:write).raises('fake network error')
     with_config(:"cross_application_tracer.enabled" => true) do
-      expected = NewRelic::Agent::TracedMethodStack.push_frame('dummy')
+      expected = NewRelic::Agent::TracedMethodStack.tl_push_frame('dummy')
       Net::HTTP.get(URI.parse('http://www.google.com/index.html')) rescue nil
-      NewRelic::Agent::TracedMethodStack.pop_frame(expected, 42)
+      NewRelic::Agent::TracedMethodStack.tl_pop_frame(expected, 42, Time.now.to_f)
     end
   end
 

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

@@ -10,6 +10,10 @@ class NewRelic::Agent::Instrumentation::QueueTimeTest < Minitest::Test
     freeze_time
   end
 
+  def teardown
+    NewRelic::Agent.drop_buffered_data
+  end
+
   def test_parse_frontend_timestamp_given_queue_start_header
     header = { 'HTTP_X_QUEUE_START' => format_header_time(Time.now - 60) }
     assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
@@ -70,9 +74,22 @@ class NewRelic::Agent::Instrumentation::QueueTimeTest < Minitest::Test
   end
 
   def test_recording_queue_time_metric
-    assert_metric_value_in_delta(60, 'WebFrontend/QueueTime', 0.001) do
+    QueueTime.record_frontend_metrics(Time.at(Time.now.to_f - 60))
+    assert_metrics_recorded(
+      'WebFrontend/QueueTime' => {
+        :call_count      => 1,
+        :total_call_time => 60
+      }
+    )
+  end
+
+  def test_doesnt_record_scoped_queue_time_metric
+    in_transaction('boo') do
       QueueTime.record_frontend_metrics(Time.at(Time.now.to_f - 60))
     end
+    assert_metrics_not_recorded(
+      [['WebFrontend/QueueTime', 'boo']]
+    )
   end
 
   def test_parsing_malformed_header

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

@@ -18,21 +18,30 @@ class MinimalRackApp
 end
 
 class NewRelic::Agent::Instrumentation::RackTest < Minitest::Test
-
   def test_basic_rack_app
     # should return what we send in, even when instrumented
     x = MinimalRackApp.new([200, {}, ["whee"]])
     assert_equal [200, {}, ["whee"]], x.call({})
+    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
   end
 
   def test_basic_rack_app_404
     x = MinimalRackApp.new([404, {}, ["whee"]])
     assert_equal [404, {}, ["whee"]], x.call({})
+    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
   end
 
   def test_basic_rack_app_ignores_404
     NewRelic::Agent::Transaction.expects(:abort_transaction!)
     x = MinimalRackApp.new([404, {}, ["whee"]])
     assert_equal [404, {}, ["whee"]], x.call({})
+    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
+  end
+
+  def test_does_not_double_instrument_middlewares
+    x = MinimalRackApp.new([200, {}, ["whee"]])
+    wrapped_x = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(x)
+
+    assert_same(x, wrapped_x)
   end
 end