ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/test/new_relic/fake_service.rb

@@ -7,13 +7,15 @@ module NewRelic
     def initialize
       @agent_data = []
       @supported_methods = [ :connect, :metric_data, :transaction_sample_data,
-                             :error_data, :sql_trace_data, :shutdown ]
+                             :error_data, :sql_trace_data, :profile_data,
+                             :get_agent_commands, :shutdown ]
       @collector = NewRelic::Control::Server.new(:name => 'fakehost', :port => 0)
       @id_counter = 0
       @base_expectations = {
         'get_redirect_host'       => 'localhost',
         'connect'                 => { 'agent_run_id' => agent_run_id },
-        'metric_data'             => { 'Some/Metric/Spec' => 1 },
+        'get_agent_commands'      => [],
+        'metric_data'             => [[{ 'name' => 'Some/Metric/Spec' }, 1]],
         'sql_trace_data'          => nil,
         'transaction_sample_data' => nil,
         'error_data'              => nil,
@@ -31,6 +33,10 @@ module NewRelic
       @id_counter = 0
       @agent_data = []
     end
+
+    def stub_service(method, value)
+      @mock[method.to_s] = value
+    end
     
     def method_missing(method, *args)
       if @supported_methods.include?(method)

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,22 @@ class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
 
   def test_passenger
     class << self
-      module ::Passenger
-        const_set "AbstractServer", 0
+      module ::PhusionPassenger
       end
     end
     e = NewRelic::LocalEnvironment.new
     assert_equal :passenger, e.environment
     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.environment
+      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 }
+    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,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+
+class NewRelic::Agent::NoticedErrorTest < Test::Unit::TestCase
+  def test_to_collector_array
+    time = Time.now
+    error = NewRelic::NoticedError.new('path', {'key' => 'val'},
+                                       Exception.new('test exception'), time)
+    expected = [
+      (time.to_f * 1000).round, 'path', 'test exception', 'Exception',
+      {'key' => 'val'}
+    ]
+    assert_equal expected, error.to_collector_array
+  end
+end

data/test/new_relic/rack/browser_monitoring_test.rb

@@ -46,11 +46,16 @@ 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'
+    }
+    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 +65,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 +116,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 +138,11 @@ 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

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/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

data/test/new_relic/transaction_sample_test.rb

@@ -5,6 +5,8 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   ::SQL_STATEMENT = "SELECT * from sandwiches"
 
   def setup
+    @test_config = { 'developer_mode' => true }
+    NewRelic::Agent.config.apply_config(@test_config)
     @connection_stub = Mocha::Mockery.instance.named_mock('connection')
     @connection_stub.stubs(:execute).returns([['QUERY RESULT']])
 
@@ -12,6 +14,10 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
     @t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
   end
 
+  def teardown
+    NewRelic::Agent.config.remove_config(@test_config)
+  end
+
   def test_be_recorded
     assert_not_nil @t
   end
@@ -78,7 +84,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
 
   def test_have_explains
     s = @t.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.00000001)
-    
+
     s.each_segment do |segment|
       if segment.params[:explain_plan]
         explanation = segment.params[:explain_plan]
@@ -138,7 +144,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
       s.to_s
     end
   end
-  
+
   def test_to_s_includes_keys
     s = @t.prepare_to_send(:explain_sql => 0.1)
     s.params[:fake_key] = 'a fake param'
@@ -174,4 +180,43 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
     end
     assert_equal 6, transaction.count_segments
   end
+
+  def test_to_array
+    expected_array = [@t.start_time.to_f,
+                      @t.params[:request_params],
+                      @t.params[:custom_params],
+                      @t.root_segment.to_array]
+    assert_equal expected_array, @t.to_array
+  end
+
+  if RUBY_VERSION >= '1.9.2'
+    def test_to_json
+      expected_string = JSON.dump([@t.start_time.to_f,
+                                   @t.params[:request_params],
+                                   @t.params[:custom_params],
+                                   @t.root_segment.to_array])
+      assert_equal expected_string, @t.to_json
+    end
+  end
+
+  def test_to_collector_array
+    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      trace_tree = compress(@t.to_json)
+    else
+      marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+      trace_tree = @t.to_array
+    end
+    expected_array = [(@t.start_time.to_f * 1000).round,
+                      (@t.duration * 1000).round,
+                      @t.params[:path], @t.params[:uri],
+                      trace_tree,
+                      @t.guid, nil, !!@t.force_persist]
+
+    assert_equal expected_array, @t.to_collector_array(marshaller)
+  end
+
+  def compress(string)
+    Base64.encode64(Zlib::Deflate.deflate(string, Zlib::DEFAULT_COMPRESSION))
+  end
 end