newrelic_rpm 3.16.0.318 → 3.16.1.320

data/test/new_relic/agent/datastores_test.rb

@@ -24,6 +24,12 @@ class NewRelic::Agent::DatastoresTest < Minitest::Test
     NewRelic::Agent::Datastores.trace self, :find,     "MyFirstDatabase"
     NewRelic::Agent::Datastores.trace self, :save,     "MyFirstDatabase", "create"
     NewRelic::Agent::Datastores.trace self, :internal, "MyFirstDatabase"
+
+    def boom
+      raise "haha"
+    end
+
+    NewRelic::Agent::Datastores.trace self, :boom, "MyFirstDatabase", "boom"
   end
 
   def setup
@@ -172,6 +178,17 @@ class NewRelic::Agent::DatastoresTest < Minitest::Test
     end
   end
 
+  def test_node_created_when_exception_occurs
+    db = MyFirstDatabase.new
+    in_transaction do
+      db.find
+      db.boom
+    end
+  rescue
+    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+    refute_nil find_node_with_name(sample, "Datastore/operation/MyFirstDatabase/boom")
+  end
+
   def assert_statement_metrics(operation, collection, type)
     assert_metrics_recorded([
                             "Datastore/statement/MyFirstDatabase/#{collection}/#{operation}",

data/test/new_relic/agent/error_collector_test.rb

@@ -250,17 +250,33 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
   end
 
   def test_extract_stack_trace
-    exception = mock('exception', :original_exception => nil,
+    exception = mock('exception', :cause => nil,
+                                  :original_exception => nil,
                                   :backtrace => nil)
 
     assert_equal('<no stack trace>', @error_collector.extract_stack_trace(exception))
   end
 
-  def test_extract_stack_trace_positive
-    orig = mock('original', :backtrace => "STACK STACK STACK")
-    exception = mock('exception', :original_exception => orig)
+  def test_extract_stack_trace_uses_cause_first
+    nested_exception = mock('exception', :backtrace => "Foo STACK")
+    exception = mock('exception', :cause => nested_exception)
 
-    assert_equal('STACK STACK STACK', @error_collector.extract_stack_trace(exception))
+    assert_equal('Foo STACK', @error_collector.extract_stack_trace(exception))
+  end
+
+  def test_extract_stack_trace_uses_original_exception_second
+    nested_exception = mock('exception', :backtrace => "Bar STACK")
+    exception = mock('exception', :cause => nil, :original_exception => nested_exception)
+
+    assert_equal('Bar STACK', @error_collector.extract_stack_trace(exception))
+  end
+
+  def test_extract_stack_trace_uses_backtrace_last
+    exception = mock('exception', :cause => nil,
+                                  :original_exception => nil,
+                                  :backtrace => "Baz STACK")
+
+    assert_equal('Baz STACK', @error_collector.extract_stack_trace(exception))
   end
 
   def test_skip_notice_error_is_true_if_the_error_collector_is_disabled

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

@@ -7,52 +7,60 @@ require 'new_relic/agent/instrumentation/active_record_helper'
 module NewRelic::Agent::Instrumentation
   class ActiveRecordHelperTest < Minitest::Test
 
-    def test_metrics_for_find
-      metrics = ActiveRecordHelper.metrics_for('Namespace::Model Load', nil, nil)
-      expected = expected_statement_metrics("find", "Namespace::Model/find")
-      assert_equal(expected, metrics)
+    def test_product_operation_collection_for_find
+      product, operation, collection = ActiveRecordHelper.product_operation_collection_for('Namespace::Model Load', nil, nil)
+      assert_equal "ActiveRecord", product
+      assert_equal "find", operation
+      assert_equal "Namespace::Model", collection
     end
 
-    def test_metrics_for_destroy
-      metrics = ActiveRecordHelper.metrics_for('Model Destroy', nil, nil)
-      expected = expected_statement_metrics("destroy", "Model/destroy")
-      assert_equal(expected, metrics)
+    def test_product_operation_collection_for_destroy
+      product, operation, collection = ActiveRecordHelper.product_operation_collection_for('Model Destroy', nil, nil)
+      assert_equal "ActiveRecord", product
+      assert_equal "destroy", operation
+      assert_equal "Model", collection
     end
 
-    def test_metrics_for_create
-      metrics = ActiveRecordHelper.metrics_for('Model Create', nil, nil)
-      expected = expected_statement_metrics("create", "Model/create")
-      assert_equal(expected, metrics)
+    def test_product_operation_collection_for_create
+      product, operation, collection = ActiveRecordHelper.product_operation_collection_for('Model Create', nil, nil)
+      assert_equal "ActiveRecord", product
+      assert_equal "create", operation
+      assert_equal "Model", collection
     end
 
-    def test_metrics_for_update
-      metrics = ActiveRecordHelper.metrics_for('Model Update', nil, nil)
-      expected = expected_statement_metrics("update", "Model/update")
-      assert_equal(expected, metrics)
+    def test_product_operation_collection_for_update
+      product, operation, collection = ActiveRecordHelper.product_operation_collection_for('Model Update', nil, nil)
+      assert_equal "ActiveRecord", product
+      assert_equal "update", operation
+      assert_equal "Model", collection
     end
 
-    def test_metric_for_name_columns
-      metrics = ActiveRecordHelper.metrics_for('Model Columns', nil, nil)
-      expected = expected_statement_metrics("columns", "Model/columns")
-      assert_equal(expected, metrics)
+    def test_product_operation_collection_for_name_columns
+      product, operation, collection = ActiveRecordHelper.product_operation_collection_for('Model Columns', nil, nil)
+      assert_equal "ActiveRecord", product
+      assert_equal "columns", operation
+      assert_equal "Model", collection
     end
 
-    def test_metric_with_product_name_from_adapter
-      metrics = ActiveRecordHelper.metrics_for('Model Load', nil, "mysql")
-      expected = expected_statement_metrics("find", "Model/find", "MySQL")
-      assert_equal(expected, metrics)
+    def test_product_operation_collection_for_with_product_name_from_adapter
+      product, operation, collection = ActiveRecordHelper.product_operation_collection_for('Model Load', nil, "mysql")
+      assert_equal "MySQL", product
+      assert_equal "find", operation
+      assert_equal "Model", collection
     end
 
-    def test_metrics_from_sql
-      metrics = ActiveRecordHelper.metrics_for('invalid', "SELECT * FROM boo", nil)
-      expected = expected_operation_metrics("select")
-      assert_equal(expected, metrics)
+    def test_product_operation_collection_for_from_sql
+      product, operation, collection = ActiveRecordHelper.product_operation_collection_for('invalid', "SELECT * FROM boo", nil)
+      assert_equal "ActiveRecord", product
+      assert_equal "select", operation
+      assert_nil collection
     end
 
-    def test_metric_for_name_with_integer_returns_nil
-      metrics = ActiveRecordHelper.metrics_for(1, '', nil)
-      expected = expected_operation_metrics("other")
-      assert_equal(expected, metrics)
+    def test_product_operation_collection_for_name_with_integer_returns_nil
+      product, operation, collection = ActiveRecordHelper.product_operation_collection_for(1, '', nil)
+      assert_equal "ActiveRecord", product
+      assert_equal "other", operation
+      assert_nil collection
     end
 
     def test_rollup_metrics_for_is_deprecated
@@ -60,18 +68,5 @@ module NewRelic::Agent::Instrumentation
       result = ActiveRecordHelper.rollup_metrics_for("boo")
       assert_equal ["Datastore/allOther", "Datastore/all"], result
     end
-
-    def expected_statement_metrics(operation, statement, product = "ActiveRecord")
-      ["Datastore/statement/#{product}/#{statement}"] +
-        expected_operation_metrics(operation, product)
-    end
-
-    def expected_operation_metrics(operation, product = "ActiveRecord")
-      ["Datastore/operation/#{product}/#{operation}",
-        "Datastore/#{product}/allOther",
-        "Datastore/#{product}/all",
-        "Datastore/allOther",
-        "Datastore/all"]
-    end
   end
 end

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

@@ -119,10 +119,9 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Minitest::T
     target_connection = ActiveRecord::Base.connection_handler.connection_pool_list.first.connections.first
     expected_config = target_connection.instance_variable_get(:@config)
 
-    event = mock('event')
-    event.stubs(:payload).returns({ :connection_id => target_connection.object_id })
+    payload = { :connection_id => target_connection.object_id }
 
-    result = @subscriber.active_record_config_for_event(event)
+    result = @subscriber.active_record_config(payload)
     assert_equal expected_config, result
   end
 end

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

@@ -9,6 +9,7 @@ class NewRelic::Agent::Instrumentation::MongodbCommandSubscriberTest < Minitest:
 
   if RUBY_VERSION > "1.9.3"
     def setup
+      freeze_time
       @started_event = mock('started event')
       @started_event.stubs(:operation_id).returns(1)
       @started_event.stubs(:command_name).returns('find')
@@ -66,6 +67,7 @@ class NewRelic::Agent::Instrumentation::MongodbCommandSubscriberTest < Minitest:
 
     def simulate_query
       @subscriber.started(@started_event)
+      advance_time @succeeded_event.duration
       @subscriber.succeeded(@succeeded_event)
     end
   end

data/test/new_relic/agent/method_tracer_test.rb

@@ -128,46 +128,38 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     assert_metrics_recorded_exclusive([])
   end
 
-  def test_trace_execution_scoped_records_metric_data_from_callback
-    metric = "hello"
-    callback_metric = "goodbye"
-    callback = Proc.new { callback_metric }
-    options = { :additional_metrics_callback => callback }
-
-    self.class.trace_execution_scoped(metric, options) do
-      advance_time 0.05
-    end
-
-    stats = @stats_engine.get_stats(callback_metric)
-    check_time 0.05, stats.total_call_time
-    assert_equal 1, stats.call_count
-  end
-
   def test_trace_execution_scoped_pushes_transaction_scope
-    self.class.trace_execution_scoped('yeap') do
-      'ptoo'
+    in_transaction do
+      self.class.trace_execution_scoped('yeap') do
+        'ptoo'
+      end
+      assert_equal 'yeap',  @scope_listener.scopes.last
     end
-    assert_equal 'yeap',  @scope_listener.scopes.last
   end
 
   def test_basic__original_api
     metric = "hello"
-    self.class.trace_method_execution(metric, true, true, true) do
-      advance_time(0.05)
+    in_transaction do |txn|
+      self.class.trace_method_execution(metric, true, true, true) do
+        advance_time(0.05)
+      end
+      assert_equal metric,  @scope_listener.scopes.last
     end
 
     stats = @stats_engine.get_stats(metric)
     check_time 0.05, stats.total_call_time
     assert_equal 1, stats.call_count
-    assert_equal metric,  @scope_listener.scopes.last
   end
 
   METRIC = "metric"
   def test_add_method_tracer
     @metric_name = METRIC
     self.class.add_method_tracer :method_to_be_traced, METRIC
+    in_transaction do
+      method_to_be_traced 1,2,3,true,METRIC
 
-    method_to_be_traced 1,2,3,true,METRIC
+      assert_equal METRIC, @scope_listener.scopes.last
+    end
 
     begin
       self.class.remove_method_tracer :method_to_be_traced, METRIC
@@ -179,7 +171,6 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     stats = @stats_engine.get_stats(METRIC)
     check_time 0.05, stats.total_call_time
     assert_equal 1, stats.call_count
-    assert_equal METRIC, @scope_listener.scopes.last
   end
 
   def test_add_method_tracer__default
@@ -238,12 +229,13 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     self.class.add_method_tracer :method_c2, "c2", :metric => false
     self.class.add_method_tracer :method_c3, "c3", :push_scope => false
 
-    method_c1
+    in_transaction do
+      method_c1
+      assert_equal ['c2', 'c1'], @scope_listener.scopes
+    end
 
     assert_metrics_recorded(['c1', 'c3'])
     assert_metrics_not_recorded('c2')
-
-    assert_equal ['c2', 'c1'], @scope_listener.scopes
   end
 
   def test_nested_scope_tracer
@@ -270,7 +262,12 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     self.class.add_method_tracer :method_to_be_traced, METRIC
     self.class.add_method_tracer :method_to_be_traced, METRIC
 
-    method_to_be_traced 1,2,3,true,METRIC
+    in_transaction do
+      method_to_be_traced 1,2,3,true,METRIC
+      assert_equal METRIC, @scope_listener.scopes.last
+      assert(METRIC != @scope_listener.scopes[-2],
+           'duplicate scope detected when redundant tracer is present')
+    end
 
     begin
       self.class.remove_method_tracer :method_to_be_traced, METRIC
@@ -281,9 +278,6 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     stats = @stats_engine.get_stats(METRIC)
     check_time 0.05, stats.total_call_time
     assert_equal 1, stats.call_count
-    assert_equal METRIC, @scope_listener.scopes.last
-    assert(METRIC != @scope_listener.scopes[-2],
-           'duplicate scope detected when redundant tracer is present')
   end
 
   def test_add_tracer_with_dynamic_metric
@@ -292,7 +286,10 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     expected_metric = "1.2"
     self.class.add_method_tracer :method_to_be_traced, metric_code
 
-    method_to_be_traced 1,2,3,true,expected_metric
+    in_transaction do
+      method_to_be_traced 1,2,3,true,expected_metric
+      assert_equal expected_metric, @scope_listener.scopes.last
+    end
 
     begin
       self.class.remove_method_tracer :method_to_be_traced, metric_code
@@ -303,20 +300,21 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
     stats = @stats_engine.get_stats(expected_metric)
     check_time 0.05, stats.total_call_time
     assert_equal 1, stats.call_count
-    assert_equal expected_metric, @scope_listener.scopes.last
   end
 
   def test_trace_method_with_block
     self.class.add_method_tracer :method_with_block, METRIC
+    in_transaction do
+      method_with_block(1,2,3,true,METRIC) do
+        advance_time 0.1
+      end
 
-    method_with_block(1,2,3,true,METRIC) do
-      advance_time 0.1
+      assert_equal METRIC, @scope_listener.scopes.last
     end
 
     stats = @stats_engine.get_stats(METRIC)
     check_time 0.15, stats.total_call_time
     assert_equal 1, stats.call_count
-    assert_equal METRIC, @scope_listener.scopes.last
   end
 
   def test_trace_module_method
@@ -351,15 +349,16 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
 
   def test_multiple_metrics__scoped
     metrics = %w[first second third]
-    self.class.trace_execution_scoped metrics do
-      advance_time 0.05
+    in_transaction do
+      self.class.trace_execution_scoped metrics do
+        advance_time 0.05
+      end
     end
     elapsed = @stats_engine.get_stats('first').total_call_time
     metrics.map{|name| @stats_engine.get_stats name}.each do | m |
       assert_equal 1, m.call_count
       assert_equal elapsed, m.total_call_time
     end
-    assert_equal 'first', @scope_listener.scopes.last
   end
 
   def test_multiple_metrics__unscoped
@@ -378,14 +377,16 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
   def test_exception
     begin
       metric = "hey"
-      self.class.trace_execution_scoped(metric) do
-        raise StandardError.new
+      in_transaction do
+        self.class.trace_execution_scoped(metric) do
+          raise StandardError.new
+        end
+        # make sure the scope gets popped
+        assert_equal metric, @scope_listener.scopes.last
       end
 
       assert false # should never get here
     rescue StandardError
-      # make sure the scope gets popped
-      assert_equal metric, @scope_listener.scopes.last
     end
 
     stats = @stats_engine.get_stats metric
@@ -393,16 +394,17 @@ class NewRelic::Agent::MethodTracerTest < Minitest::Test
   end
 
   def test_add_multiple_tracers
-    self.class.add_method_tracer :method_to_be_traced, 'XX', :push_scope => false
-    method_to_be_traced 1,2,3,true,nil
-    self.class.add_method_tracer :method_to_be_traced, 'YY'
-    method_to_be_traced 1,2,3,true,'YY'
-    self.class.remove_method_tracer :method_to_be_traced, 'YY'
-    method_to_be_traced 1,2,3,true,nil
-    self.class.remove_method_tracer :method_to_be_traced, 'XX'
-    method_to_be_traced 1,2,3,false,'XX'
-
-    assert_equal ['YY'], @scope_listener.scopes
+    in_transaction do
+      self.class.add_method_tracer :method_to_be_traced, 'XX', :push_scope => false
+      method_to_be_traced 1,2,3,true,nil
+      self.class.add_method_tracer :method_to_be_traced, 'YY'
+      method_to_be_traced 1,2,3,true,'YY'
+      self.class.remove_method_tracer :method_to_be_traced, 'YY'
+      method_to_be_traced 1,2,3,true,nil
+      self.class.remove_method_tracer :method_to_be_traced, 'XX'
+      method_to_be_traced 1,2,3,false,'XX'
+      assert_equal ['YY'], @scope_listener.scopes
+    end
   end
 
   def test_add_method_tracer_module_double_inclusion

data/test/new_relic/agent/mock_scope_listener.rb

@@ -18,7 +18,10 @@ class NewRelic::Agent::MockScopeListener
     @scopes << scope
   end
 
-  def on_finishing_transaction(time)
+  def on_start_transaction(state, start_time)
+  end
+
+  def on_finishing_transaction(state, txn, time=Time.now)
   end
 
   def enabled?

data/test/new_relic/agent/sql_sampler_test.rb

@@ -64,6 +64,21 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     assert_equal 2, @sampler.tl_transaction_data.sql_data.size
   end
 
+  def test_notice_sql_statement
+    @sampler.on_start_transaction(@state, nil)
+
+    sql = "select * from test"
+    metric_name = "Database/test/select"
+    statement = NewRelic::Agent::Database::Statement.new sql, {:adapter => :mysql}
+
+    @sampler.notice_sql_statement(statement, metric_name, 1.5)
+
+    slow_sql =  @sampler.tl_transaction_data.sql_data[0]
+
+    assert_equal statement, slow_sql.statement
+    assert_equal metric_name, slow_sql.metric_name
+  end
+
   def test_notice_sql_truncates_query
     @sampler.on_start_transaction(@state, nil)
     message = 'a' * 17_000