newrelic_rpm 3.5.4.35.beta → 3.5.5.38

data/test/new_relic/agent/configuration/manager_test.rb

@@ -1,5 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 require 'new_relic/agent/configuration/manager'
+require 'new_relic/agent/configuration/mask_defaults'
 
 module NewRelic::Agent::Configuration
   class ManagerTest < Test::Unit::TestCase
@@ -91,15 +92,56 @@ module NewRelic::Agent::Configuration
       assert_equal 'correct value', @manager[:setting]
     end
 
-    def test_flattened_config
+    def test_dotted_hash_to_hash_is_plain_hash
+      dotted = NewRelic::Agent::Configuration::DottedHash.new({})
+      assert_equal(::Hash, dotted.to_hash.class)
+    end
+
+    def test_to_collector_hash
       @manager.instance_variable_set(:@config_stack, [])
       @manager.apply_config(:eins => Proc.new { self[:one] })
       @manager.apply_config(:one => 1)
       @manager.apply_config(:two => 2)
-      @manager.apply_config(:three => 3)
+      @manager.apply_config(:nested => {:madness => 'test'})
+      @manager.apply_config(:'nested.madness' => 'test')
+
+      assert_equal({ :eins => 1, :one => 1, :two => 2, :'nested.madness' => 'test' },
+                   @manager.to_collector_hash)
+    end
+
+    # Necessary to keep the pruby marshaller happy
+    def test_to_collector_hash_returns_bare_hash
+      @manager.instance_variable_set(:@config_stack, [])
+      @manager.apply_config(:eins => Proc.new { self[:one] })
+
+      assert_equal(::Hash, @manager.to_collector_hash.class)
+    end
+
+    def test_config_masks
+      NewRelic::Agent::Configuration::MASK_DEFAULTS[:boo] = Proc.new { true }
+
+      @manager.apply_config(:boo => 1)
+
+      assert_equal false, @manager.to_collector_hash.has_key?(:boo)
+    end
 
-      assert_equal({ :eins => 1, :one => 1, :two => 2, :three => 3 },
-                   @manager.flattened_config)
+    def test_config_masks_conditionally
+      NewRelic::Agent::Configuration::MASK_DEFAULTS[:boo] = Proc.new { false }
+
+      @manager.apply_config(:boo => 1)
+
+      assert @manager.to_collector_hash.has_key?(:boo)
+    end
+
+    def test_config_masks_thread_profiler
+      supported = NewRelic::Agent::ThreadProfiler.is_supported?
+      reported_config = @manager.to_collector_hash
+
+      if supported
+        assert_not_nil reported_config[:'thread_profiler.enabled']
+      else
+        assert_equal nil, reported_config[:'thread_profiler.enabled']
+      end
     end
 
     def test_replacing_a_layer_by_class
@@ -140,6 +182,19 @@ module NewRelic::Agent::Configuration
       assert_equal 'right', state
     end
 
+    def test_should_log_when_applying
+      expects_logging(:debug, anything, includes("asdf"))
+      @manager.apply_config(:test => "asdf")
+    end
+
+    def test_should_log_when_removing
+      config = { :test => "asdf" }
+      @manager.apply_config(config)
+
+      expects_logging(:debug, anything, Not(includes("asdf")))
+      @manager.remove_config(config)
+    end
+
     class TestSource < ::Hash
       def test_config_accessor
         'some value'

data/test/new_relic/agent/configuration/yaml_source_test.rb

@@ -49,8 +49,27 @@ module NewRelic::Agent::Configuration
     end
 
     def test_should_log_if_no_file_is_found
-      NewRelic::Control.instance.log.expects(:error)
+      expects_logging(:error, any_parameters)
       source = YamlSource.new('no_such_file.yml', 'test')
     end
+
+    def test_should_not_fail_to_log_missing_file_during_startup
+      without_logger do
+        ::NewRelic::Agent::StartupLogger.any_instance.expects(:error)
+        source = YamlSource.new('no_such_file.yml', 'test')
+      end
+    end
+
+    def test_should_not_fail_to_log_invalid_file_during_startup
+      without_logger do
+        ::NewRelic::Agent::StartupLogger.any_instance.expects(:error)
+
+        File.stubs(:exists?).returns(true)
+        File.stubs(:read).raises(StandardError.new("boo"))
+
+        source = YamlSource.new('fake.yml', 'test')
+      end
+    end
+
   end
 end

data/test/new_relic/agent/cross_process_monitoring_test.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+module NewRelic::Agent
+  class CrossProcessMonitoringTest < Test::Unit::TestCase
+    AGENT_CROSS_PROCESS_ID = "qwerty"
+    REQUEST_CROSS_PROCESS_ID = "asdf"
+
+    def setup
+      NewRelic::Agent.instance.stubs(:cross_process_id).returns(AGENT_CROSS_PROCESS_ID)
+      NewRelic::Agent.instance.stubs(:cross_process_encoding_bytes).returns([0])
+
+      @request_with_id = stub(:env => {'X-NewRelic-ID' => REQUEST_CROSS_PROCESS_ID})
+      @empty_request = stub(:env => {})
+
+      @response = {}
+    end
+
+    def test_adds_response_header
+      timings = stub(
+        :transaction_name => "transaction",
+        :queue_time_in_millis => 1000,
+        :app_time_in_millis => 2000)
+
+      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(timings)
+
+      CrossProcessMonitoring.insert_response_header(@request_with_id, @response)
+
+      assert unpacked_response.include?("transaction")
+      assert unpacked_response.include?("1000")
+      assert unpacked_response.include?("2000")
+      assert unpacked_response.include?(AGENT_CROSS_PROCESS_ID)
+    end
+
+    def test_doesnt_add_header_if_no_id_in_request
+      CrossProcessMonitoring.insert_response_header(@empty_request, @response)
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_add_header_if_no_id_on_agent
+      NewRelic::Agent.instance.stubs(:cross_process_id).returns(nil)
+
+      CrossProcessMonitoring.insert_response_header(@request_with_id, @response)
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_add_header_if_config_disabled
+      with_config(:'cross_process.enabled' => false) do
+        CrossProcessMonitoring.insert_response_header(@request_with_id, @response)
+        assert_nil response_app_data
+      end
+    end
+
+    def test_finds_id_from_headers
+      %w{X-NewRelic-ID HTTP_X_NEWRELIC_ID X_NEWRELIC_ID}.each do |key|
+        request = stub(:env => { key => REQUEST_CROSS_PROCESS_ID })
+
+        assert_equal(
+          REQUEST_CROSS_PROCESS_ID, \
+          CrossProcessMonitoring.id_from_request(request),
+          "Failed to find header on key #{key}")
+      end
+    end
+
+    def test_doesnt_find_id_in_headers
+      request = stub(:env => {})
+      assert_nil CrossProcessMonitoring.id_from_request(request)
+    end
+
+    def response_app_data
+      @response['X-NewRelic-App-Data']
+    end
+
+    def unpacked_response
+      response_app_data.unpack("m0").first
+    end
+  end
+end

data/test/new_relic/agent/database_test.rb

@@ -73,17 +73,6 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     assert_equal([], NewRelic::Agent::Database.explain_sql('SELECT', config))
   end  
   
-  def test_handle_exception_in_explain
-    fake_error = StandardError.new('a message')
-    NewRelic::Control.instance.log.expects(:error).with('Error getting query plan: a message')
-    # backtrace can be basically any string, just should get logged
-    NewRelic::Control.instance.log.expects(:debug).with(instance_of(String))
-    
-    NewRelic::Agent::Database.handle_exception_in_explain do
-      raise(fake_error)
-    end
-  end
-  
   def test_obfuscation_mysql_basic
     insert = %q[INSERT INTO `X` values("test",0, 1 , 2, 'test')]
     assert_equal("INSERT INTO `X` values(?,?, ? , ?, ?)",

data/test/new_relic/agent/error_collector/notice_error_test.rb

@@ -126,9 +126,7 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
 
   def test_over_queue_limit_positive
     @errors = %w(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
-    fake_log = mock('log')
-    self.expects(:log).returns(fake_log)
-    fake_log.expects(:warn).with('The error reporting queue has reached 20. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: hooray')
+    expects_logging(:warn, includes('The error reporting queue has reached 20'))
     assert over_queue_limit?('hooray')
   end
 

data/test/new_relic/agent/error_collector_test.rb

@@ -5,10 +5,17 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   def setup
     super
+    @test_config = { :capture_params => true }
+    NewRelic::Agent.config.apply_config(@test_config)
     @error_collector = NewRelic::Agent::ErrorCollector.new
     @error_collector.stubs(:enabled).returns(true)
   end
-  
+
+  def teardown
+    super
+    NewRelic::Agent.config.remove_config(@test_config)
+  end
+
   def test_empty
     @error_collector.harvest_errors([])
     @error_collector.notice_error(nil, :metric=> 'path', :request_params => {:x => 'y'})
@@ -27,7 +34,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert_equal 'path', err.path
     assert_equal 'Error', err.exception_class
   end
-  
+
   def test_simple
     @error_collector.notice_error(StandardError.new("message"), :uri => '/myurl/', :metric => 'path', :referer => 'test_referer', :request_params => {:x => 'y'})
 
@@ -115,7 +122,6 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
 
 
   def test_supported_param_types
-
     types = [[1, '1'],
     [1.1, '1.1'],
     ['hi', 'hi'],
@@ -124,10 +130,9 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     [TestClass.new, "#<NewRelic::Agent::ErrorCollectorTest::TestClass>"]
     ]
 
-
     types.each do |test|
-      @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => test[0]})
-
+      @error_collector.notice_error(StandardError.new("message"), :metric => 'path',
+                                    :request_params => {:x => test[0]})
       assert_equal test[1], @error_collector.harvest_errors([])[0].params[:request_params][:x]
     end
   end
@@ -156,7 +161,6 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_exclude_block
-    NewRelic::Agent.logger.expects(:error).never
     @error_collector.ignore_error_filter &wrapped_filter_proc
         
     @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})

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

@@ -45,9 +45,13 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"
 
     assert_calls_metrics(find_metric) do
-      ActiveRecordFixtures::Order.find(:all)
+      all_finder(ActiveRecordFixtures::Order)
       check_metric_count(find_metric, 1)
-      ActiveRecordFixtures::Order.find_all_by_name "jeff"
+      if NewRelic::Control.instance.rails_version >= "4"
+        ActiveRecordFixtures::Order.where(:name =>  "jeff").load
+      else
+        ActiveRecordFixtures::Order.find_all_by_name "jeff"
+      end
       check_metric_count(find_metric, 2)
     end
   end
@@ -74,9 +78,9 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"
     ActiveRecordFixtures::Order.cache do
-      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+      m = ActiveRecordFixtures::Order.create :id => 1, :name => 'jeff'
       assert_calls_metrics(find_metric) do
-        ActiveRecordFixtures::Order.find(:all)
+        all_finder(ActiveRecordFixtures::Order)
       end
 
       check_metric_count(find_metric, 1)
@@ -151,7 +155,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     # 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.
     return if defined?(JRuby) || isSqlite?
-    
+
     expected = %W[
       ActiveRecord/all
       ActiveRecord/find
@@ -169,14 +173,14 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     end
 
     assert_calls_metrics(*expected) do
-      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'donkey'
+      m = ActiveRecordFixtures::Order.create :id => 1, :name => 'donkey'
       m = ActiveRecordFixtures::Order.find(m.id)
       m.id = 999
       m.save!
     end
 
     metrics = NewRelic::Agent.instance.stats_engine.metrics
-        
+
     compare_metrics expected, metrics
     check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/find", 1)
     if NewRelic::Control.instance.rails_version < '3.0.0'
@@ -261,7 +265,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   end
 
   def test_join_metrics_standard
-    return if (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i == 3)
+    return if (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i >= 3)
     return if defined?(JRuby) || isSqlite?
 
     expected_metrics = %W[
@@ -357,7 +361,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     ActiveRecordFixtures::Order.add_delay
     NewRelic::Agent.disable_all_tracing do
       perform_action_with_newrelic_trace :name => 'bogosity' do
-        ActiveRecordFixtures::Order.find(:all)
+        all_finder(ActiveRecordFixtures::Order)
       end
     end
     assert_nil NewRelic::Agent.instance.transaction_sampler.last_sample
@@ -368,7 +372,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   def test_run_explains
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
-      ActiveRecordFixtures::Order.find(:all)
+      all_finder(ActiveRecordFixtures::Order)
     end
 
     # that's a mouthful. perhaps we should ponder our API.
@@ -381,7 +385,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   def test_prepare_to_send
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
-      ActiveRecordFixtures::Order.find(:all)
+      all_finder(ActiveRecordFixtures::Order)
     end
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
     assert_not_nil sample
@@ -412,7 +416,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     sample = NewRelic::Agent.instance.transaction_sampler.reset!
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
-      ActiveRecordFixtures::Order.find(:all)
+      all_finder(ActiveRecordFixtures::Order)
     end
 
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
@@ -442,7 +446,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     sample = NewRelic::Agent.instance.transaction_sampler.reset!
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
-      ActiveRecordFixtures::Order.find(:all)
+      all_finder(ActiveRecordFixtures::Order)
     end
 
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
@@ -467,7 +471,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     sample = NewRelic::Agent.instance.transaction_sampler.reset!
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
-      ActiveRecordFixtures::Order.find(:all)
+      all_finder(ActiveRecordFixtures::Order)
     end
 
     sample = NewRelic::Agent.instance.transaction_sampler.last_sample
@@ -482,10 +486,12 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   # These are only valid for rails 2.1 and later
   if NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("2.1.0")
     ActiveRecordFixtures::Order.class_eval do
-      if NewRelic::Control.instance.rails_version < NewRelic::VersionNumber.new("3.1")
-        named_scope :jeffs, :conditions => { :name => 'Jeff' }
-      else
+      if NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("4")
+        scope :jeffs, lambda { where(:name => 'Jeff') }
+      elsif NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("3.1")
         scope :jeffs, :conditions => { :name => 'Jeff' }
+      else
+        named_scope :jeffs, :conditions => { :name => 'Jeff' }
       end      
     end
     def test_named_scope
@@ -495,7 +501,11 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
       check_metric_count(find_metric, 0)
       assert_calls_metrics(find_metric) do
-        x = ActiveRecordFixtures::Order.jeffs.find(:all)
+        if NewRelic::Control.instance.rails_version >= "4"
+          x = ActiveRecordFixtures::Order.jeffs.load
+        else
+          x = ActiveRecordFixtures::Order.jeffs.find(:all)
+        end
       end
       check_metric_count(find_metric, 1)
     end
@@ -566,7 +576,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   private
 
   def rails3?
-    (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i == 3)
+    (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i >= 3)
   end
 
   def rails_env
@@ -583,4 +593,14 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   def isSqlite?
     ActiveRecord::Base.configurations[rails_env]['adapter'] =~ /sqlite/i
   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
+    else
+      relation.find(:all)
+    end
+  end
 end

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

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+class NewRelic::Agent::Instrumentation::BrowserMonitoringTimingsTest < Test::Unit::TestCase
+
+  def setup
+    Time.stubs(:now).returns(2000)
+    @transaction = stub(
+      :transaction_name => "Name",
+      :start_time => 0
+    )
+  end
+
+  def test_queue_time
+    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(1000.1234, @transaction)
+    assert_equal 1_000_123, t.queue_time_in_millis
+  end
+
+  def test_queue_time_clamps_to_positive
+    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(-1000, @transaction)
+    assert_equal 0, t.queue_time_in_millis
+  end
+
+  def test_app_time
+    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(nil, @transaction)
+    assert_equal 2_000_000, t.app_time_in_millis
+  end
+
+  def test_transaction_name
+    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(nil, @transaction)
+    assert_equal "Name", t.transaction_name
+  end
+
+  def test_defaults_to_transaction_info
+    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(1000, nil)
+    assert_equal nil, t.transaction_name
+    assert_equal 0.0, t.start_time_in_millis
+  end
+
+end