newrelic_rpm 3.6.8.168 → 3.6.9.171

data/test/multiverse/suites/sinatra/sinatra_metric_explosion_test.rb

@@ -64,8 +64,21 @@ class SinatraMetricExplosionTest < MiniTest::Unit::TestCase
     get '/another_controller'
 
     metric_names = ::NewRelic::Agent.agent.stats_engine.metrics
-    metric_names -= ['CPU/User Time', "Middleware/all", "WebFrontend/QueueTime", "WebFrontend/WebServer/all"]
-    metric_names.delete_if {|metric| metric.start_with?("Supportability")}
+    metric_names -= [
+      'CPU/User Time',
+      "Middleware/all",
+      "WebFrontend/QueueTime",
+      "WebFrontend/WebServer/all",
+    ]
+
+    name_beginnings_to_ignore = [
+      "Supportability",
+      "GC/cumulative"
+    ]
+    metric_names.delete_if do|metric|
+      name_beginnings_to_ignore.any? {|name| metric.start_with?(name)}
+    end
+
     assert_equal 6, metric_names.size, "Explosion detected in: #{metric_names.inspect}"
   end
 

data/test/multiverse/suites/typhoeus/typhoeus_test.rb

@@ -43,6 +43,14 @@ if NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
       Typhoeus::Request.post(default_url, ssl_option.merge(:body => ""))
     end
 
+    def put_response
+      Typhoeus::Request.put(default_url, ssl_option.merge(:body => ""))
+    end
+
+    def delete_response
+      Typhoeus::Request.delete(default_url, ssl_option)
+    end
+
     def request_instance
       NewRelic::Agent::HTTPClients::TyphoeusHTTPRequest.new(Typhoeus::Request.new("http://newrelic.com"))
     end

data/test/new_relic/agent/agent/connect_test.rb

@@ -18,6 +18,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     @transaction_sampler = NewRelic::Agent::TransactionSampler.new
     @sql_sampler = NewRelic::Agent::SqlSampler.new
     @error_collector = NewRelic::Agent::ErrorCollector.new
+    @stats_engine = NewRelic::Agent::StatsEngine.new
     server = NewRelic::Control::Server.new('localhost', 30303)
     @service = NewRelic::Agent::NewRelicService.new('abcdef', server)
     @test_config = { :developer_mode => true }
@@ -195,7 +196,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
                                     { 'match_expression' => 'xx',
                                       'replacement'      => 'XX' } ]
     }
-    finish_setup(config)
+    NewRelic::Agent.instance.finish_setup(config)
 
     rules = NewRelic::Agent.instance.transaction_rules
     assert_equal 2, rules.size
@@ -219,7 +220,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     }
     finish_setup(config)
 
-    rules = NewRelic::Agent.instance.metric_rules
+    rules = @stats_engine.metric_rules
     assert_equal 2, rules.size
     assert(rules.find{|r| r.match_expression == /77/ && r.replacement == '&&' },
            "rule not found among #{rules}")

data/test/new_relic/agent/agent_test.rb

@@ -25,6 +25,12 @@ module NewRelic
         assert_equal 123, @agent.service.channel_id
       end
 
+      def test_after_fork_reporting_to_channel_should_not_collect_environment_report
+        @agent.stubs(:connected?).returns(true)
+        @agent.expects(:generate_environment_report).never
+        @agent.after_fork(:report_to_channel => 123)
+      end
+
       def test_after_fork_should_close_pipe_if_parent_not_connected
         pipe = mock
         pipe.expects(:after_fork_in_child)
@@ -49,6 +55,20 @@ module NewRelic
         end
       end
 
+      def test_after_fork_should_reset_errors_collected
+        with_config(:monitor_mode => true) do
+          @agent.stubs(:connected?).returns(true)
+
+          errors = []
+          errors << NewRelic::NoticedError.new("", {}, Exception.new("boo"))
+          @agent.merge_data_from([{}, [], errors])
+
+          @agent.after_fork(:report_to_channel => 123)
+
+          assert_equal 0, @agent.error_collector.errors.length, "Still got errors collected in parent"
+        end
+      end
+
       def test_transmit_data_should_emit_before_harvest_event
         got_it = false
         @agent.events.subscribe(:before_harvest) { got_it = true }
@@ -71,19 +91,7 @@ module NewRelic
         @agent.instance_eval { transmit_data }
       end
 
-      def test_transmit_data_should_handle_eoferror
-        @agent.service.stubs(:metric_data).raises(EOFError)
-        expects_no_logging(:error)
-        expects_logging(:warn, regexp_matches(/EOFError/))
-        expects_logging(:debug, is_a(EOFError))
-        @agent.instance_eval { transmit_data }
-      end
-
-      def test_harvest_transaction_traces
-        assert_equal([], @agent.send(:harvest_transaction_traces), 'should return transaction traces')
-      end
-
-      def test_harvest_and_send_slowest_sample
+      def test_harvest_and_send_transaction_traces
         with_config(:'transaction_tracer.explain_threshold' => 2,
                     :'transaction_tracer.explain_enabled' => true,
                     :'transaction_tracer.record_sql' => 'raw') do
@@ -92,11 +100,38 @@ module NewRelic
                        :transaction_name => nil,
                        :force_persist => true,
                        :truncate => 4000)
-          trace.expects(:prepare_to_send).with(:record_sql => :raw,
-                                               :explain_sql => 2,
-                                               :keep_backtraces => true)
-          @agent.instance_variable_set(:@traces, [ trace ])
-          @agent.send :harvest_and_send_slowest_sample
+          trace.expects(:prepare_to_send!).with(:record_sql => :raw,
+                                               :explain_sql => 2)
+
+          @agent.transaction_sampler.stubs(:harvest).returns([trace])
+          @agent.send :harvest_and_send_transaction_traces
+        end
+      end
+
+      def test_harvest_and_send_transaction_traces_merges_back_on_failure
+        traces = [mock('tt1'), mock('tt2')]
+
+        # make prepare_to_send just return self
+        traces.each { |tt| tt.expects(:prepare_to_send!).returns(tt) }
+
+        @agent.transaction_sampler.expects(:harvest).returns(traces)
+        @agent.service.stubs(:transaction_sample_data).raises("wat")
+        @agent.transaction_sampler.expects(:merge!).with(traces)
+
+        assert_nothing_raised do
+          @agent.send :harvest_and_send_transaction_traces
+        end
+      end
+
+      def test_harvest_and_send_errors_merges_back_on_failure
+        errors = [mock('e0'), mock('e1')]
+
+        @agent.error_collector.expects(:harvest_errors).returns(errors)
+        @agent.service.stubs(:error_data).raises('wat')
+        @agent.error_collector.expects(:merge!).with(errors)
+
+        assert_nothing_raised do
+          @agent.send :harvest_and_send_errors
         end
       end
 
@@ -131,10 +166,6 @@ module NewRelic
         end
       end
 
-      def test_harvest_errors
-        assert_equal([], @agent.send(:harvest_errors), 'should return errors')
-      end
-
       def test_handle_for_agent_commands
         @agent.service.expects(:get_agent_commands).returns([]).once
         @agent.send :check_for_and_handle_agent_commands
@@ -147,67 +178,18 @@ module NewRelic
       end
 
       def test_merge_data_from_empty
-        unsent_timeslice_data = mock('unsent timeslice data')
-        unsent_errors = mock('unsent errors')
-        unsent_traces = mock('unsent traces')
-        @agent.instance_eval {
-          @unsent_errors = unsent_errors
-          @unsent_timeslice_data = unsent_timeslice_data
-          @traces = unsent_traces
-        }
-        # nb none of the others should receive merge requests
-        @agent.merge_data_from([{}])
-      end
-
-      def test_unsent_errors_size_empty
-        @agent.instance_eval {
-          @unsent_errors = nil
-        }
-        assert_equal(nil, @agent.unsent_errors_size)
-      end
-
-      def test_unsent_errors_size_with_errors
-        @agent.instance_eval {
-          @unsent_errors = ['an error']
-        }
-        assert_equal(1, @agent.unsent_errors_size)
-      end
-
-      def test_unsent_traces_size_empty
-        @agent.instance_eval {
-          @traces = nil
-        }
-        assert_equal(nil, @agent.unsent_traces_size)
-      end
-
-      def test_unsent_traces_size_with_traces
-        @agent.instance_eval {
-          @traces = ['a trace']
-        }
-        assert_equal(1, @agent.unsent_traces_size)
-      end
-
-      def test_unsent_timeslice_data_empty
-        @agent.instance_eval {
-          @unsent_timeslice_data = nil
-        }
-        assert_equal(0, @agent.unsent_timeslice_data, "should have zero timeslice data to start")
-        assert_equal({}, @agent.instance_variable_get('@unsent_timeslice_data'), "should initialize the timeslice data to an empty hash if it is empty")
-      end
-
-      def test_unsent_timeslice_data_with_errors
-        @agent.instance_eval {
-          @unsent_timeslice_data = {:key => 'value'}
-        }
-        assert_equal(1, @agent.unsent_timeslice_data, "should have the key from above")
+        @agent.stats_engine.expects(:merge!).never
+        @agent.error_collector.expects(:merge!).never
+        @agent.transaction_sampler.expects(:merge!).never
+        @agent.merge_data_from([])
       end
 
       def test_merge_data_traces
-        unsent_traces = mock('unsent traces')
+        transaction_sampler = mock('transaction sampler')
         @agent.instance_eval {
-          @traces = unsent_traces
+          @transaction_sampler = transaction_sampler
         }
-        unsent_traces.expects(:+).with([1,2,3])
+        transaction_sampler.expects(:merge!).with([1,2,3])
         @agent.merge_data_from([{}, [1,2,3], []])
       end
 
@@ -230,7 +212,7 @@ module NewRelic
         samples = [mock('some analytics event')]
 
         request_sampler.expects(:harvest).returns(samples)
-        request_sampler.expects(:merge).with(samples)
+        request_sampler.expects(:merge!).with(samples)
 
         # simulate a failure in transmitting analytics events
         service.stubs(:analytic_event_data).raises(StandardError.new)
@@ -240,6 +222,18 @@ module NewRelic
         end
       end
 
+      def test_harvest_and_send_timeslice_data_merges_back_on_failure
+        timeslices = mock('timeslices')
+
+        @agent.stats_engine.expects(:harvest).returns(timeslices)
+        @agent.service.stubs(:metric_data).raises('wat')
+        @agent.stats_engine.expects(:merge!).with(timeslices)
+
+        assert_nothing_raised do
+          @agent.send(:harvest_and_send_timeslice_data)
+        end
+      end
+
       def test_connect_retries_on_timeout
         service = @agent.service
         service.stubs(:connect).raises(Timeout::Error).then.returns(nil)
@@ -286,8 +280,9 @@ module NewRelic
         @agent.send(:connect, :force_reconnect => true)
       end
 
-      def test_defer_start_if_resque_dispatcher_and_channel_manager_isnt_started
-        NewRelic::Agent::PipeChannelManager.listener.expects(:started?).returns(false)
+      def test_defer_start_if_resque_dispatcher_and_channel_manager_isnt_started_and_forkable
+        NewRelic::LanguageSupport.stubs(:can_fork?).returns(true)
+        NewRelic::Agent::PipeChannelManager.listener.stubs(:started?).returns(false)
 
         # :send_data_on_exit setting to avoid setting an at_exit
         with_config( :send_data_on_exit => false, :dispatcher => :resque ) do
@@ -298,7 +293,19 @@ module NewRelic
       end
 
       def test_doesnt_defer_start_if_resque_dispatcher_and_channel_manager_started
-        NewRelic::Agent::PipeChannelManager.listener.expects(:started?).returns(true)
+        NewRelic::Agent::PipeChannelManager.listener.stubs(:started?).returns(true)
+
+        # :send_data_on_exit setting to avoid setting an at_exit
+        with_config( :send_data_on_exit => false, :dispatcher => :resque ) do
+          @agent.start
+        end
+
+        assert @agent.started?
+      end
+
+      def test_doesnt_defer_start_for_resque_if_non_forking_platform
+        NewRelic::LanguageSupport.stubs(:can_fork?).returns(false)
+        NewRelic::Agent::PipeChannelManager.listener.stubs(:started?).returns(false)
 
         # :send_data_on_exit setting to avoid setting an at_exit
         with_config( :send_data_on_exit => false, :dispatcher => :resque ) do

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -107,6 +107,30 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     assert_equal "", header
   end
 
+  def test_browser_timing_header_with_loader_without_js_errors_beta
+    with_config(:js_agent_loader => 'loader') do
+      header = browser_timing_header
+      assert_equal("<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header,
+                   "expected old RUM header but saw '#{header}'")
+    end
+  end
+
+  def test_browser_timing_header_with_js_errors_beta_without_loader
+    with_config(:js_errors_beta => true) do
+      header = browser_timing_header
+      assert_equal("<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header,
+                   "expected old RUM header but saw '#{header}'")
+    end
+  end
+
+  def test_browser_timing_header_with_js_errors_beta_and_loader
+    with_config(:js_errors_beta => true, :js_agent_loader => 'loader') do
+      header = browser_timing_header
+      assert_equal("\n<script type=\"text/javascript\">loader</script>", header,
+                   "expected new JS agent loader 'loader' but saw '#{header}'")
+    end
+  end
+
   def test_browser_timing_footer
     with_config(:license_key => 'a' * 13) do
       NewRelic::Agent::TransactionState.reset
@@ -139,7 +163,7 @@ var e=document.createElement("script");'
     end
   end
 
-  def test_browser_timing_footer_with_rum_enabled_not_specified
+  def setup_beacon_config
     NewRelic::Agent::TransactionState.reset
     browser_timing_header
 
@@ -148,6 +172,11 @@ var e=document.createElement("script");'
     config =  NewRelic::Agent::BeaconConfiguration.new
     config.expects(:license_bytes).returns(license_bytes).at_least_once
     NewRelic::Agent.instance.stubs(:beacon_configuration).returns(config).at_least_once
+  end
+
+  def test_browser_timing_footer_with_rum_enabled_not_specified
+    setup_beacon_config
+
     footer = browser_timing_footer
     beginning_snippet = '<script type="text/javascript">if (typeof NREUMQ !== "undefined") { if (!NREUMQ.f) { NREUMQ.f=function() {
 NREUMQ.push(["load",new Date().getTime()]);
@@ -210,6 +239,20 @@ var e=document.createElement("script");'
     end
   end
 
+  def test_browser_timing_footer_with_js_errors_beta_and_loader
+    with_config(:js_errors_beta => true, :js_agent_loader => 'loader') do
+      setup_beacon_config
+
+      footer = browser_timing_footer
+      beginning_snippet = "\n<script type=\"text/javascript\">window.NREUM||(NREUM={});NREUM.info={\""
+      ending_snippet = '}</script>'
+      assert(footer.include?(beginning_snippet),
+             "expected footer to include beginning snippet: '#{beginning_snippet}', but was '#{footer}'")
+      assert(footer.include?(ending_snippet),
+             "expected footer to include ending snippet: '#{ending_snippet}', but was '#{footer}'")
+    end
+  end
+
   def test_browser_monitoring_transaction_name_basic
     txn = NewRelic::Agent::Transaction.new
     txn.name = 'a transaction name'

data/test/new_relic/agent/error_collector_test.rb

@@ -22,14 +22,14 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_empty
-    @error_collector.harvest_errors([])
+    @error_collector.harvest_errors
     @error_collector.notice_error(nil, :metric=> 'path', :request_params => {:x => 'y'})
-    errors = @error_collector.harvest_errors([])
+    errors = @error_collector.harvest_errors
 
     assert_equal 0, errors.length
 
     @error_collector.notice_error('Some error message', :metric=> 'path', :request_params => {:x => 'y'})
-    errors = @error_collector.harvest_errors([])
+    errors = @error_collector.harvest_errors
 
     err = errors.first
     assert_equal 'Some error message', err.message
@@ -44,8 +44,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   def test_simple
     @error_collector.notice_error(StandardError.new("message"), :uri => '/myurl/', :metric => 'path', :referer => 'test_referer', :request_params => {:x => 'y'})
 
-    old_errors = []
-    errors = @error_collector.harvest_errors(old_errors)
+    errors = @error_collector.harvest_errors
 
     assert_equal errors.length, 1
 
@@ -60,7 +59,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
 
     # the collector should now return an empty array since nothing
     # has been added since its last harvest
-    errors = @error_collector.harvest_errors(nil)
+    errors = @error_collector.harvest_errors
     assert errors.length == 0
   end
 
@@ -69,8 +68,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     #still 1 byte / char.
     @error_collector.notice_error(StandardError.new("1234567890" * 500), :uri => '/myurl/', :metric => 'path', :request_params => {:x => 'y'})
 
-    old_errors = []
-    errors = @error_collector.harvest_errors(old_errors)
+    errors = @error_collector.harvest_errors
 
     assert_equal errors.length, 1
 
@@ -82,22 +80,22 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   def test_collect_failover
     @error_collector.notice_error(StandardError.new("message"), :metric => 'first', :request_params => {:x => 'y'})
 
-    errors = @error_collector.harvest_errors([])
+    errors = @error_collector.harvest_errors
 
     @error_collector.notice_error(StandardError.new("message"), :metric => 'second', :request_params => {:x => 'y'})
     @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
     @error_collector.notice_error(StandardError.new("message"), :metric => 'last', :request_params => {:x => 'y'})
 
-    errors = @error_collector.harvest_errors(errors)
+    @error_collector.merge!(errors)
+    errors = @error_collector.harvest_errors
 
     assert_equal 4, errors.length
-    assert_equal 'first', errors.first.path
-    assert_equal 'last', errors.last.path
+    assert_equal_unordered(%w(first second path last), errors.map { |e| e.path })
 
     @error_collector.notice_error(StandardError.new("message"), :metric => 'first', :request_params => {:x => 'y'})
     @error_collector.notice_error(StandardError.new("message"), :metric => 'last', :request_params => {:x => 'y'})
 
-    errors = @error_collector.harvest_errors(nil)
+    errors = @error_collector.harvest_errors
     assert_equal 2, errors.length
     assert_equal 'first', errors.first.path
     assert_equal 'last', errors.last.path
@@ -113,7 +111,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
       end
     end
 
-    errors = @error_collector.harvest_errors([])
+    errors = @error_collector.harvest_errors
     assert errors.length == max_q_length
     errors.each_index do |i|
       err = errors.shift
@@ -140,7 +138,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     types.each do |test|
       @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]
+      assert_equal test[1], @error_collector.harvest_errors[0].params[:request_params][:x]
     end
   end
 
@@ -150,7 +148,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
 
     @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
 
-    errors = @error_collector.harvest_errors([])
+    errors = @error_collector.harvest_errors
 
     assert_equal 0, errors.length
   end
@@ -161,7 +159,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     NewRelic::Agent.config.apply_config(:'error_collector.ignore_errors' => "IOError")
     @error_collector.notice_error(IOError.new("message"))
 
-    errors = @error_collector.harvest_errors([])
+    errors = @error_collector.harvest_errors
 
     assert_equal 1, errors.length
 
@@ -173,7 +171,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
     @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
 
-    errors = @error_collector.harvest_errors([])
+    errors = @error_collector.harvest_errors
 
     assert_equal 1, errors.length
   end
@@ -183,8 +181,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
       @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))
       @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo in (1,2,3,4,5)"))
 
-      old_errors = []
-      errors = @error_collector.harvest_errors([])
+      errors = @error_collector.harvest_errors
 
       assert_equal(NewRelic::NoticedError::STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE, errors[0].message)
       assert_equal(NewRelic::NoticedError::STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE, errors[1].message)