wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/new_relic/load_test.rb

@@ -0,0 +1,13 @@
+# require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'test/unit'
+require 'resolv'
+require 'mocha'
+
+class LoadTest < Test::Unit::TestCase
+  def test_loading_agent_when_disabled_does_not_resolv_addresses
+    ::Resolv.expects(:getaddress).never
+    ::IPSocket.expects(:getaddress).never
+
+    require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+  end
+end

data/test/new_relic/local_environment_test.rb

@@ -28,25 +28,25 @@ class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
 
   def test_passenger
     class << self
-      module ::Passenger
-        const_set "AbstractServer", 0
+      module ::PhusionPassenger
       end
     end
+    NewRelic::Agent.reset_config
     e = NewRelic::LocalEnvironment.new
-    assert_equal :passenger, e.environment
+    assert_equal :passenger, e.discovered_dispatcher
+    assert_equal :passenger, NewRelic::Agent.config[:dispatcher]
     assert_nil e.dispatcher_instance_id, "dispatcher instance id should be nil: #{e.dispatcher_instance_id}"
 
-    NewRelic::Control.instance.instance_eval do
-      @settings['app_name'] = 'myapp'
+    with_config(:app_name => 'myapp') do
+      e = NewRelic::LocalEnvironment.new
+      assert_equal :passenger, e.discovered_dispatcher
+      assert_nil e.dispatcher_instance_id
     end
 
-    e = NewRelic::LocalEnvironment.new
-    assert_equal :passenger, e.environment
-    assert_nil e.dispatcher_instance_id
-
-    ::Passenger.class_eval { remove_const :AbstractServer }
+  ensure
+    Object.send(:remove_const, :PhusionPassenger)
   end
-  
+
   def test_snapshot
     e = NewRelic::LocalEnvironment.new
     s = e.snapshot

data/test/new_relic/metric_data_test.rb

@@ -14,50 +14,49 @@ class NewRelic::MetricDataTest < Test::Unit::TestCase
   def test_eql_basic
     spec = mock('metric_spec')
     stats = mock('stats')
-    metric_id = mock('metric_id')    
+    metric_id = mock('metric_id')
     md1 = NewRelic::MetricData.new(spec, stats, metric_id)
     md2 = NewRelic::MetricData.new(spec, stats, metric_id)
     assert(md1.eql?(md2), "The example metric data objects should be eql?: #{md1.inspect} #{md2.inspect}")
-    assert(md2.eql?(md1), "The example metric data objects should be eql?: #{md1.inspect} #{md2.inspect}")    
+    assert(md2.eql?(md1), "The example metric data objects should be eql?: #{md1.inspect} #{md2.inspect}")
   end
 
   def test_eql_unequal_specs
-    
     spec = mock('metric_spec')
     other_spec = mock('other_spec')
     stats = mock('stats')
-    metric_id = mock('metric_id')    
+    metric_id = mock('metric_id')
     md1 = NewRelic::MetricData.new(spec, stats, metric_id)
     md2 = NewRelic::MetricData.new(other_spec, stats, metric_id)
     assert(!md1.eql?(md2), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
-    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")    
+    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
   end
   def test_eql_unequal_stats
     spec = mock('metric_spec')
     stats = mock('stats')
     other_stats = mock('other_stats')
-    metric_id = mock('metric_id')    
+    metric_id = mock('metric_id')
     md1 = NewRelic::MetricData.new(spec, stats, metric_id)
     md2 = NewRelic::MetricData.new(spec, other_stats, metric_id)
     assert(!md1.eql?(md2), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
-    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")    
+    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
   end
 
   def test_eql_unequal_metric_ids_dont_matter
     spec = mock('metric_spec')
     stats = mock('stats')
     metric_id = mock('metric_id')
-    other_metric_id = mock('other_metric_id')    
+    other_metric_id = mock('other_metric_id')
     md1 = NewRelic::MetricData.new(spec, stats, metric_id)
     md2 = NewRelic::MetricData.new(spec, stats, other_metric_id)
     assert(md1.eql?(md2), "The example metric data objects should be eql? with different metric_ids: #{md1.inspect} #{md2.inspect}")
-    assert(md2.eql?(md1), "The example metric data objects should be eql? with different metric_ids: #{md1.inspect} #{md2.inspect}")    
+    assert(md2.eql?(md1), "The example metric data objects should be eql? with different metric_ids: #{md1.inspect} #{md2.inspect}")
   end
 
   def test_original_spec_basic
     spec = mock('metric_spec')
     stats = mock('stats')
-    metric_id = mock('metric_id')    
+    metric_id = mock('metric_id')
     md1 = NewRelic::MetricData.new(spec, stats, metric_id)
     original_spec = md1.instance_variable_get('@original_spec')
     assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
@@ -66,26 +65,26 @@ class NewRelic::MetricDataTest < Test::Unit::TestCase
 
   def test_metric_spec_equal_should_not_set_original_spec_with_no_metric_spec
     stats = mock('stats')
-    metric_id = mock('metric_id')    
+    metric_id = mock('metric_id')
     md1 = NewRelic::MetricData.new(nil, stats, metric_id)
     original_spec = md1.instance_variable_get('@original_spec')
     assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
-    
+
     new_spec = mock('new metric_spec')
     assert_equal(new_spec, md1.metric_spec=(new_spec), "should return the new spec")
 
     new_original_spec = md1.instance_variable_get('@original_spec')
     assert_equal(nil, new_original_spec, "should not set @original_spec  but was #{new_original_spec.inspect}")
   end
-  
+
   def test_metric_spec_equal_should_set_original_spec_with_existing_metric_spec
     spec = mock('metric_spec')
     stats = mock('stats')
-    metric_id = mock('metric_id')    
+    metric_id = mock('metric_id')
     md1 = NewRelic::MetricData.new(spec, stats, metric_id)
     original_spec = md1.instance_variable_get('@original_spec')
     assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
-    
+
     new_spec = mock('new metric_spec')
     assert_equal(new_spec, md1.metric_spec=(new_spec), "should return the new spec")
 
@@ -96,7 +95,7 @@ class NewRelic::MetricDataTest < Test::Unit::TestCase
   def test_hash
     spec = mock('metric_spec')
     stats = mock('stats')
-    metric_id = mock('metric_id')    
+    metric_id = mock('metric_id')
     md1 = NewRelic::MetricData.new(spec, stats, metric_id)
     assert((spec.hash ^ stats.hash) == md1.hash, "expected #{spec.hash ^ stats.hash} to equal #{md1.hash}")
   end
@@ -122,4 +121,34 @@ class NewRelic::MetricDataTest < Test::Unit::TestCase
     md = NewRelic::MetricData.new(nil, NewRelic::MethodTraceStats.new, 12345)
     assert_equal('12345: [01/01/70 12:00AM UTC, 0.000s;  0 calls    0s]', md.to_s, "should include the metric id and not have a metric spec")
   end
+
+  def test_to_collector_array_with_spec
+    stats = NewRelic::MethodTraceStats.new
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', 'scope'),
+                                  stats, nil)
+    expected = [ {'name' => 'Custom/test/method', 'scope' => 'scope'},
+                 [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_spec_and_id
+    stats = NewRelic::MethodTraceStats.new
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', 'scope'),
+                                  stats, 1234)
+    expected = [ 1234, [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_id
+    stats = NewRelic::MethodTraceStats.new
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    md = NewRelic::MetricData.new(nil, stats, 1234)
+    expected = [ 1234, [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
+    assert_equal expected, md.to_collector_array
+  end
 end

data/test/new_relic/noticed_error_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+
+class NewRelic::Agent::NoticedErrorTest < Test::Unit::TestCase
+  def setup
+    @path = 'foo/bar/baz'
+    @params = { 'key' => 'val' }
+    @time = Time.now
+  end
+
+  def test_to_collector_array
+    e = Exception.new('test exception')
+    error = NewRelic::NoticedError.new(@path, @params, e, @time)
+    expected = [
+      (@time.to_f * 1000).round, @path, 'test exception', 'Exception', @params
+    ]
+    assert_equal expected, error.to_collector_array
+  end
+
+  def test_handles_non_string_exception_messages
+    e = Exception.new({ :non => :string })
+    error = NewRelic::NoticedError.new(@path, @params, e, @time)
+    assert_equal(String, error.message.class)
+  end
+end

data/test/new_relic/rack/browser_monitoring_test.rb

@@ -9,7 +9,7 @@ ENV['RACK_ENV'] = 'test'
 # benefit from auto-rum, but the truth of the matter is that atm
 # we only support Rails >= 2.3
 def middleware_supported?
-  ::Rails::VERSION::MAJOR >= 2 && ::Rails::VERSION::MINOR >= 3
+  ::Rails::VERSION::STRING >= '2.3'
 end
 
 if middleware_supported?
@@ -46,11 +46,17 @@ EOL
   def setup
     super
     clear_cookies
+    @config = {
+      :browser_key => 'some browser key',
+      :beacon => 'beacon',
+      :application_id => 5,
+      :'rum.enabled' => true,
+      :episodes_file => 'this_is_my_file',
+      :license_key => 'a' * 40
+    }
+    NewRelic::Agent.config.apply_config(@config)
     NewRelic::Agent.manual_start
-    config = NewRelic::Agent::BeaconConfiguration.new("browser_key" => "browserKey",
-                                                      "application_id" => "apId",
-                                                      "beacon"=>"beacon",
-                                                      "episodes_url"=>"this_is_my_file")
+    config = NewRelic::Agent::BeaconConfiguration.new
     NewRelic::Agent.instance.stubs(:beacon_configuration).returns(config)
     NewRelic::Agent.stubs(:is_transaction_traced?).returns(true)
   end
@@ -60,6 +66,7 @@ EOL
     clear_cookies
     mocha_teardown
     TestApp.doc = nil
+    NewRelic::Agent.config.remove_config(@config)
   end
 
   def test_make_sure_header_is_set
@@ -110,7 +117,7 @@ EOL
   def test_insert_timing_footer_right_before_html_body_close
     get '/'
 
-    assert_match(/.*NREUMQ\.push.*new Date\(\)\.getTime\(\),"","","","",""\]\)<\/script><\/body>/,
+    assert_match(/.*NREUMQ\.push.*new Date\(\)\.getTime\(\),"","","","",""\]\);<\/script><\/body>/,
                  last_response.body)
   end
 
@@ -132,11 +139,14 @@ EOL
   def test_guid_is_set_in_footer_when_token_is_set
     guid = 'abcdefgfedcba'
     NewRelic::TransactionSample.any_instance.stubs(:generate_guid).returns(guid)
-    NewRelic::Control.instance.stubs(:apdex_t).returns(0.0001)
     set_cookie "NRAGENT=tk=token"
-    get '/'
-
-    assert(last_response.body.include?(guid), last_response.body)
+    with_config(:apdex_t => 0.0001) do
+      get '/'
+      assert(last_response.body.include?(guid), last_response.body)
+    end
   end
 end
+else
+  warn "Skipping rum auto instrumentation tests"
 end
+

data/test/new_relic/rack/developer_mode_test.rb

@@ -14,32 +14,38 @@ class DeveloperModeTest < Test::Unit::TestCase
     mock_app = lambda { |env| [500, {}, "Don't touch me!"] }
     NewRelic::Rack::DeveloperMode.new(mock_app)
   end
-  
+
   def setup
+    @test_config = { :developer_mode => true }
+    NewRelic::Agent.config.apply_config(@test_config)
     @sampler = NewRelic::Agent::TransactionSampler.new
     run_sample_trace_on(@sampler, '/here')
     run_sample_trace_on(@sampler, '/there')
     run_sample_trace_on(@sampler, '/somewhere')
     NewRelic::Agent.instance.stubs(:transaction_sampler).returns(@sampler)
   end
-  
+
+  def teardown
+    NewRelic::Agent.config.remove_config(@test_config)
+  end
+
   def test_index_displays_all_samples
     get '/newrelic'
-    
+
     assert last_response.ok?
     assert last_response.body.include?('/here')
     assert last_response.body.include?('/there')
-    assert last_response.body.include?('/somewhere')    
+    assert last_response.body.include?('/somewhere')
   end
 
   def test_show_sample_summary_displays_sample_details
     get "/newrelic/show_sample_summary?id=#{@sampler.samples[0].sample_id}"
-    
+
     assert last_response.ok?
     assert last_response.body.include?('/here')
     assert last_response.body.include?('SandwichesController')
-    assert last_response.body.include?('index')    
-  end  
+    assert last_response.body.include?('index')
+  end
 
   def test_explain_sql_displays_query_plan
     sample = @sampler.samples[0]

data/test/new_relic/rack/error_collector_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..',
+                                   'test_helper'))
+require 'rack/test'
+require 'new_relic/rack/error_collector'
+
+module NewRelic::Rack
+  class ErrorCollectorTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    class TestApp
+      def call(env)
+        if env['PATH_INFO'] == '/ignored'
+          env['action_dispatch.request.parameters'] = {
+            'controller' => 'test_ignore',
+            'action'     => 'ignored'
+          }
+        end
+        raise 'unhandled error'
+      end
+    end
+
+    def app
+      NewRelic::Rack::ErrorCollector.new(TestApp.new)
+    end
+
+    def setup
+      NewRelic::Agent.reset_config
+      NewRelic::Agent.manual_start
+      NewRelic::Agent.instance.error_collector
+      NewRelic::Agent.instance.error_collector.errors = []
+
+      # sanity checks
+      assert NewRelic::Agent.instance.error_collector.enabled?
+      NewRelic::Agent.instance.error_collector \
+        .instance_variable_set(:@ignore_filter, nil)
+      assert !NewRelic::Agent.instance.error_collector.ignore_error_filter
+    end
+
+    def test_notice_and_reraise_errors
+      assert_raise RuntimeError do
+        get '/'
+      end
+
+      assert_equal('unhandled error',
+                   NewRelic::Agent.instance.error_collector.errors[0].message)
+    end
+
+    def test_ignore_filtered_errors
+      NewRelic::Agent.instance.error_collector.ignore_error_filter do |error|
+        !error.kind_of?(RuntimeError)
+      end
+
+      assert_raise RuntimeError do
+        get '/'
+      end
+
+      assert(NewRelic::Agent.instance.error_collector.errors.empty?,
+             'noticed an error that should have been ignored')
+    end
+
+    def test_ignore_errors_from_ignored_actions
+      assert_raise RuntimeError do
+        get '/ignored'
+      end
+
+      assert(NewRelic::Agent.instance.error_collector.errors.empty?,
+             'noticed an error that should have been ignored')
+    end
+  end
+end
+
+class TestIgnoreController
+  @do_not_trace = { :only => :ignored }
+end

data/test/new_relic/stats_test.rb

@@ -399,6 +399,16 @@ class NewRelic::StatsTest < Test::Unit::TestCase
     assert_in_delta(s3.standard_deviation, 4.743, 0.01)
   end
 
+  if RUBY_VERSION >= '1.9'
+    def test_to_json_enforces_float_values
+      s1 = NewRelic::MethodTraceStats.new
+      s1.trace_call 3.to_r
+      s1.trace_call 7.to_r
+
+      assert_equal 3.0, JSON.load(s1.to_json)['min_call_time']
+    end
+  end
+
   private
   def validate (stats, count, total, min, max, exclusive = nil)
     assert_equal stats.call_count, count

data/test/new_relic/transaction_sample/segment_test.rb

@@ -39,10 +39,29 @@ class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
     s.to_s
   end
 
-  def test_to_json
-    t = Time.now
-    s = NewRelic::TransactionSample::Segment.new(t, 'Custom/test/metric', nil)
-    assert_equal({ :entry_timestamp => t, :exit_timestamp => nil, :metric_name => 'Custom/test/metric', :segment_id => s.object_id }.to_json, s.to_json)
+  def test_to_array
+    parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent', 1)
+    parent.params[:test] = 'value'
+    child = NewRelic::TransactionSample::Segment.new(2, 'Custom/test/child', 2)
+    child.end_trace(3)
+    parent.add_called_segment(child)
+    parent.end_trace(4)
+    expected_array = [1000, 4000, 'Custom/test/parent', {:test => 'value'},
+                      [[2000, 3000, 'Custom/test/child', {}, []]]]
+    assert_equal(expected_array, parent.to_array)
+  end
+
+  if RUBY_VERSION >= '1.9.2'
+    def test_to_json
+      parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent', 1)
+      parent.params[:test] = 'value'
+      child = NewRelic::TransactionSample::Segment.new(2, 'Custom/test/child', 2)
+      child.end_trace(3)
+      parent.add_called_segment(child)
+      parent.end_trace(4)
+      expected_string = "[1000,4000,\"Custom/test/parent\",{\"test\":\"value\"},[[2000,3000,\"Custom/test/child\",{},[]]]]"
+      assert_equal(expected_string, parent.to_json)
+    end
   end
 
   def test_path_string