newrelic_rpm 3.6.0.74.beta → 3.6.0.78

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

@@ -0,0 +1,52 @@
+# 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/instrumentation/active_record_helper'
+
+class NewRelic::Agent::Instrumentation::ActiveRecordHelperTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation
+
+  def test_metric_for_name_find
+    metric_name = 'ActiveRecord/Model/find'
+    assert_equal metric_name, ActiveRecordHelper.metric_for_name('Model Find')
+    assert_equal metric_name, ActiveRecordHelper.metric_for_name('Model Load')
+    assert_equal metric_name, ActiveRecordHelper.metric_for_name('Model Count')
+    assert_equal metric_name, ActiveRecordHelper.metric_for_name('Model Exists')
+  end
+
+  def test_metric_for_name_with_namespace
+    assert_equal('ActiveRecord/Namespace::Model/find',
+                 ActiveRecordHelper.metric_for_name('Namespace::Model Load'))
+  end
+
+  def test_metric_for_name_destroy
+    assert_equal('ActiveRecord/Model/destroy',
+                 ActiveRecordHelper.metric_for_name('Model Destroy'))
+  end
+
+  def test_metric_for_name_create
+    assert_equal('ActiveRecord/Model/create',
+                 ActiveRecordHelper.metric_for_name('Model Create'))
+  end
+
+  def test_metric_for_name_update
+    assert_equal('ActiveRecord/Model/save',
+                 ActiveRecordHelper.metric_for_name('Model Update'))
+  end
+
+  def test_metric_for_name_columns
+    assert_nil ActiveRecordHelper.metric_for_name('Model Columns')
+  end
+
+  def test_rollup_metric_for_lists_rollups
+    rollup_metrics = ActiveRecordHelper.rollup_metrics_for('ActiveRecord/Model/find')
+    assert rollup_metrics.include?('ActiveRecord/find')
+    assert rollup_metrics.include?('ActiveRecord/all')
+  end
+
+  def test_remote_service_metric
+    assert_equal('RemoteService/sql/mysql/server',
+                 ActiveRecordHelper.remote_service_metric('mysql', 'server'))
+  end
+end

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

@@ -31,6 +31,8 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
   def teardown
     super
+    NewRelic::Agent::TransactionInfo.reset
+    Thread::current[:newrelic_scope_name] = nil
     NewRelic::Agent.shutdown
   end
 
@@ -74,28 +76,6 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     end
   end
 
-  # multiple duplicate find calls should only cause metric trigger on the first
-  # call.  the others are ignored.
-  def test_query_cache
-    # Not sure why we get a transaction error with sqlite
-    return if isSqlite?
-
-    find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"
-    ActiveRecordFixtures::Order.cache do
-      m = ActiveRecordFixtures::Order.create :id => 1, :name => 'jeff'
-      assert_calls_metrics(find_metric) do
-        all_finder(ActiveRecordFixtures::Order)
-      end
-
-      check_metric_count(find_metric, 1)
-
-      assert_calls_metrics(find_metric) do
-        10.times { ActiveRecordFixtures::Order.find m.id }
-      end
-      check_metric_count(find_metric, 2)
-    end
-  end
-
   def test_metric_names_jruby
     # fails due to a bug in rails 3 - log does not provide the correct
     # transaction type - it returns 'SQL' instead of 'Foo Create', for example.
@@ -352,7 +332,6 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     return if isPostgres?
 
     expected_metrics = %W[ActiveRecord/all Database/SQL/show RemoteService/sql/#{adapter}/localhost]
-
     assert_calls_metrics(*expected_metrics) do
       ActiveRecordFixtures::Order.connection.execute "show tables"
     end
@@ -372,7 +351,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     metrics = NewRelic::Agent.instance.stats_engine.metrics
     compare_metrics [], metrics
   end
-  
+
   def test_run_explains
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
@@ -380,12 +359,11 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     end
 
     # that's a mouthful. perhaps we should ponder our API.
-    segment = NewRelic::Agent.instance.transaction_sampler.last_sample \
-      .root_segment.called_segments[0].called_segments[0].called_segments[0]
+    segment = last_segment(NewRelic::Agent.instance.transaction_sampler.last_sample)
     regex = /^SELECT (["`]?#{ActiveRecordFixtures::Order.table_name}["`]?.)?\* FROM ["`]?#{ActiveRecordFixtures::Order.table_name}["`]?$/
     assert_match regex, segment.params[:sql].strip
   end
-  
+
   def test_prepare_to_send
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
@@ -397,14 +375,12 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     includes_gc = false
     sample.each_segment {|s| includes_gc ||= s.metric_name =~ /GC/ }
 
-    assert_equal (includes_gc ? 4 : 3), sample.count_segments, sample.to_s
-
-    sql_segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
+    sql_segment = last_segment(sample)
     assert_not_nil sql_segment, sample.to_s
     assert_match /^SELECT /, sql_segment.params[:sql]
     assert sql_segment.duration > 0.0, "Segment duration must be greater than zero."
     sample = sample.prepare_to_send(:record_sql => :raw, :explain_sql => 0.0)
-    sql_segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
+    sql_segment = last_segment(sample)
     assert_match /^SELECT /, sql_segment.params[:sql]
     explanations = sql_segment.params[:explain_plan]
     if isMysql? || isPostgres?
@@ -416,6 +392,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
   def test_transaction_mysql
     return unless isMysql? && !defined?(JRuby)
+
     ActiveRecordFixtures.setup
     sample = NewRelic::Agent.instance.transaction_sampler.reset!
     perform_action_with_newrelic_trace :name => 'bogosity' do
@@ -424,9 +401,8 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     end
 
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-
     sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
-    segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
+    segment = last_segment(sample)
     explanation = segment.params[:explain_plan]
     assert_not_nil explanation, "No explains in segment: #{segment}"
     assert_equal 2, explanation.size,"No explains in segment: #{segment}"
@@ -456,7 +432,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
 
     sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
-    segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
+    segment = last_segment(sample)
     explanations = segment.params[:explain_plan]
 
     assert_not_nil explanations, "No explains in segment: #{segment}"
@@ -481,7 +457,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
 
     sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
-    segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
+    segment = last_segment(sample)
 
     s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
     assert_equal 1, s.call_count
@@ -496,7 +472,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
         scope :jeffs, :conditions => { :name => 'Jeff' }
       else
         named_scope :jeffs, :conditions => { :name => 'Jeff' }
-      end      
+      end
     end
     def test_named_scope
       ActiveRecordFixtures::Order.create :name => 'Jeff'
@@ -552,31 +528,24 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       assert_equal 'preserve-me!', e.message
     end
   end
-  
+
   def test_remote_service_metric_respects_dynamic_connection_config
     return unless isMysql?
 
-#     puts NewRelic::Agent::Database.config.inspect
-    
     ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
     assert(NewRelic::Agent.get_stats("RemoteService/sql/#{adapter}/localhost").call_count != 0)
 
-    config = ActiveRecordFixtures::Shipment.connection.instance_eval { @config }    
+    config = ActiveRecordFixtures::Shipment.connection.instance_eval { @config }
     config[:host] = '127.0.0.1'
     connection = ActiveRecordFixtures::Shipment.establish_connection(config)
-    
-#     puts ActiveRecord::Base.connection.instance_eval { @config }.inspect
-#     puts NewRelic::Agent::Database.config.inspect
-    
+
     ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
     assert(NewRelic::Agent.get_stats("RemoteService/sql/#{adapter}/127.0.0.1").call_count != 0)
 
     config[:host] = 'localhost'
     ActiveRecordFixtures::Shipment.establish_connection(config)
-
-#     raise NewRelic::Agent.instance.stats_engine.inspect
   end
-  
+
   private
 
   def rails3?
@@ -599,12 +568,24 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   end
 
   def all_finder(relation)
-    if NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("4.0")
-      relation.all.load
-    elsif NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("3.0")
-      relation.all
+    if defined?(::ActiveRecord::VERSION)
+      if ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+        relation.all.load
+      elsif ::ActiveRecord::VERSION::MAJOR.to_i >= 3
+        relation.all
+      else
+        relation.find(:all)
+      end
     else
       relation.find(:all)
     end
   end
+
+  def last_segment(txn_sample)
+    last = nil
+    txn_sample.root_segment.each_segment do |segment|
+      last = segment
+    end
+    last
+  end
 end

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

@@ -0,0 +1,132 @@
+# 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/instrumentation/rails4/active_record'
+
+if ::Rails::VERSION::MAJOR.to_i >= 4 && !NewRelic::LanguageSupport.using_engine?('jruby')
+class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Test::Unit::TestCase
+  class Order; end
+
+  def setup
+    @config = { :adapter => 'mysql', :host => 'server' }
+    @connection = Object.new
+    @connection.instance_variable_set(:@config, @config)
+    Order.stubs(:connection_pool).returns(stub(:connections => [ @connection ]))
+
+    @params = {
+      :name => 'NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order Load',
+      :sql => 'SELECT * FROM sandwiches',
+      :connection_id => @connection.object_id
+    }
+
+    @subscriber = NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new
+
+    @stats_engine = NewRelic::Agent.instance.stats_engine
+    @stats_engine.clear_stats
+  end
+
+  def test_records_metrics_for_simple_find
+    t1 = Time.now
+    t0 = t1 - 2
+    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+
+    metric_name = 'ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
+
+    metric = @stats_engine.lookup_stats(metric_name)
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+  end
+
+  def test_records_scoped_metrics
+    t1 = Time.now
+    t0 = t1 - 2
+
+    @stats_engine.start_transaction('test_txn')
+    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+
+    metric_name = 'ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
+
+    scoped_metric = @stats_engine.lookup_stats(metric_name, 'test_txn')
+    assert_equal(1, scoped_metric.call_count)
+    assert_equal(2.0, scoped_metric.total_call_time)
+  end
+
+  def test_records_nothing_if_tracing_disabled
+    t1 = Time.now
+    t0 = t1 - 2
+
+    NewRelic::Agent.disable_all_tracing do
+      @subscriber.call('sql.active_record', t0, t1, :id, @params)
+    end
+
+    metric = @stats_engine \
+      .lookup_stats('ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find')
+    assert_nil metric
+  end
+
+  def test_records_rollup_metrics
+    t1 = Time.now
+    t0 = t1 - 2
+
+    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+
+    ['ActiveRecord/find', 'ActiveRecord/all'].each do |metric_name|
+      metric = @stats_engine.lookup_stats(metric_name)
+      assert_equal(1, metric.call_count,
+                   "Incorrect call count for #{metric_name}")
+      assert_equal(2.0, metric.total_call_time,
+                   "Incorrect call time for #{metric_name}")
+    end
+  end
+
+  def test_records_remote_service_metric
+    t1 = Time.now
+    t0 = t1 - 2
+
+    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+
+    metric = @stats_engine.lookup_stats('RemoteService/sql/mysql/server')
+    assert_equal(1, metric.call_count)
+    assert_equal(2.0, metric.total_call_time)
+  end
+
+  def test_creates_txn_segment
+    t1 = Time.now
+    t0 = t1 - 2
+
+    NewRelic::Agent.manual_start
+    @stats_engine.start_transaction('test')
+    sampler = NewRelic::Agent.instance.transaction_sampler
+    sampler.notice_first_scope_push(Time.now.to_f)
+    sampler.notice_transaction('/path', '/path', {})
+    sampler.notice_push_scope('Controller/sandwiches/index')
+    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+    sampler.notice_pop_scope('Controller/sandwiches/index')
+    sampler.notice_scope_empty
+
+    last_segment = nil
+    sampler.last_sample.root_segment.each_segment{|s| last_segment = s }
+    NewRelic::Agent.shutdown
+
+    assert_equal('ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find',
+                 last_segment.metric_name)
+    assert_equal('SELECT * FROM sandwiches',
+                 last_segment.params[:sql])
+  end
+
+  def test_creates_slow_sql_node
+    NewRelic::Agent.manual_start
+    sampler = NewRelic::Agent.instance.sql_sampler
+    sampler.notice_first_scope_push nil
+    t1 = Time.now
+    t0 = t1 - 2
+
+    @subscriber.call('sql.active_record', t0, t1, :id, @params)
+
+    assert_equal 'SELECT * FROM sandwiches', sampler.transaction_data.sql_data[0].sql
+  ensure
+    NewRelic::Agent.shutdown
+  end
+end
+end

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

@@ -461,4 +461,24 @@ class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Test::Unit::Tes
       end
     end
   end
+
+  def test_doesnt_misbehave_when_transaction_tracing_is_disabled
+    @engine.transaction_sampler = nil
+
+    # The error should have any other consequence other than logging the error, so
+    # this will capture logs
+    logger = NewRelic::Agent::MemoryLogger.new
+    NewRelic::Agent.logger = logger
+
+    with_config(:"cross_application_tracer.enabled" => true) do
+      Net::HTTP.get(URI.parse('http://www.google.com/index.html'))
+    end
+
+    assert_no_match( /undefined method `rename_scope_segment' for nil:NilClass/i,
+                     logger.messages.flatten.map {|log| log.to_s }.join(' ') )
+
+  ensure
+    @engine.transaction_sampler = NewRelic::Agent.agent.transaction_sampler
+  end
+
 end

data/test/new_relic/agent_test.rb

@@ -62,14 +62,6 @@ module NewRelic
       NewRelic::Agent.after_fork
     end
 
-    def test_after_fork_sets_forked_flag
-      agent = NewRelic::Agent::Agent.new
-      assert !agent.forked?
-      agent.after_fork
-
-      assert agent.forked?
-    end
-
     if NewRelic::LanguageSupport.can_fork? &&
         !NewRelic::LanguageSupport.using_version?('1.9.1')
       def test_timeslice_harvest_with_after_fork_report_to_channel

data/test/new_relic/control_test.rb

@@ -48,9 +48,8 @@ class NewRelic::ControlTest < Test::Unit::TestCase
 
   def test_info
     NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
-    props = NewRelic::Control.instance.local_env.snapshot
     if defined?(Rails)
-      assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last, props.inspect
+      assert_match /jdbc|postgres|mysql|sqlite/, NewRelic::EnvironmentReport.new["Database adapter"]
     end
   end
 

data/test/new_relic/dispatcher_test.rb

@@ -13,11 +13,7 @@ class DispatcherTest < Test::Unit::TestCase
   end
 
   def assert_dispatcher_reported_to_environment_report(dispatcher)
-    NewRelic::Control.instance.local_env.gather_environment_info
-    key, value = NewRelic::Control.instance.local_env.snapshot.detect do |(k, v)|
-      k == "Dispatcher"
-    end
-    assert_equal dispatcher.to_s, value
+    assert_equal dispatcher.to_s, NewRelic::EnvironmentReport.new["Dispatcher"]
   end
 
   def test_detects_dispatcher_via_loaded_libraries

data/test/new_relic/environment_report_test.rb

@@ -0,0 +1,89 @@
+# 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/environment_report'
+
+class EnvironmentReportTest < Test::Unit::TestCase
+  def setup
+    @old_logic = ::NewRelic::EnvironmentReport.registered_reporters.dup
+    @report = ::NewRelic::EnvironmentReport.new
+  end
+
+  def teardown
+    ::NewRelic::EnvironmentReport.registered_reporters = @old_logic
+  end
+
+  def test_converts_to_array
+    ::NewRelic::EnvironmentReport.report_on("something"){"awesome"}
+    data = Array(::NewRelic::EnvironmentReport.new)
+    expected = ["something", "awesome"]
+    assert data.include?(expected), "expected to find #{expected} in #{data.inspect}"
+  end
+
+  def test_register_a_value_to_report_on
+    ::NewRelic::EnvironmentReport.report_on("What time is it?") do
+      "beer-o-clock"
+    end
+    assert_equal 'beer-o-clock', ::NewRelic::EnvironmentReport.new["What time is it?"]
+  end
+
+  def test_report_on_handles_errors_gracefully
+    assert_nothing_raised do
+      ::NewRelic::EnvironmentReport.report_on("What time is it?") do
+        raise ArgumentError, "woah! something blew up"
+      end
+      assert_nil ::NewRelic::EnvironmentReport.new["What time is it?"]
+    end
+  end
+
+  def test_it_does_not_set_keys_for_nil_values
+    ::NewRelic::EnvironmentReport.report_on("What time is it?") do
+      nil
+    end
+    assert ! NewRelic::EnvironmentReport.new.data.has_key?("What time is it?")
+  end
+
+  def test_can_set_an_environment_value_directly
+    @report['My Value'] = "so awesome!!"
+    assert_equal "so awesome!!", @report['My Value']
+  end
+
+  def test_it_knows_what_gems_are_in_the_environment
+    assert(@report['Gems'].size > 5, "Expected at least 5 gems in #{@report['Gems'].inspect}")
+    rake = @report['Gems'].detect{|s| s.include? 'rake'}
+    assert_match(/^rake\([\d\.]+\)$/, rake)
+  end
+
+  def test_gathers_ruby_version
+    assert_equal RUBY_VERSION, @report['Ruby version']
+  end
+
+  def test_has_logic_for_keys
+    [
+      "Gems",
+      "Plugin List",
+      "Ruby version",
+      "Ruby description",
+      "Ruby platform",
+      "Ruby patchlevel",
+      'JRuby version',
+      'Java VM version',
+      'Processors',
+      'Database adapter',
+      'Framework',
+      'Dispatcher',
+      'Environment',
+      'Arch',
+      'OS version',
+      'OS',
+      'Rails Env',
+      'Rails version',
+      'Rails threadsafe',
+    ].each do |key|
+      assert NewRelic::EnvironmentReport.registered_reporters.has_key?(key), "Expected logic for #{key.inspect} in EnvironmentReport."
+    end
+  end
+end