newrelic_rpm 3.6.7.159 → 3.6.8.164

data/test/multiverse/suites/rails/request_statistics_test.rb

@@ -30,7 +30,7 @@ class RequestStatsTest < ActionController::TestCase
   #
 
   def test_doesnt_send_when_disabled
-    with_config( :'request_sampler.enabled' => false ) do
+    with_config( :'analytics_events.enabled' => false ) do
       20.times { get :stats_action }
 
       NewRelic::Agent.agent.send(:harvest_and_send_analytic_event_data)
@@ -40,7 +40,7 @@ class RequestStatsTest < ActionController::TestCase
   end
 
   def test_request_times_should_be_reported_if_enabled
-    with_config( :'request_sampler.enabled' => true ) do
+    with_config( :'analytics_events.enabled' => true ) do
       20.times { get :stats_action }
 
       NewRelic::Agent.agent.send(:harvest_and_send_analytic_event_data)

data/test/multiverse/suites/rails/view_instrumentation_test.rb

@@ -121,13 +121,13 @@ end
 class NormalishRenderTest < ViewControllerTest
   test "should count all the template and partial segments" do
     get :template_render_with_3_partial_renders
-    sample = NewRelic::Agent.agent.transaction_sampler.samples.last
+    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
     assert_equal 5, sample.count_segments, "should be a node for the controller action, the template, and 3 partials (5)"
   end
 
   test "should have 3 segments with the metric name 'View/views/_a_partial.html.erb/Partial'" do
     get :template_render_with_3_partial_renders
-    sample = NewRelic::Agent.agent.transaction_sampler.samples.last
+    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
 
     partial_segments = sample.root_segment.called_segments.first.called_segments.first.called_segments
     assert_equal 3, partial_segments.size, "sanity check"
@@ -141,13 +141,13 @@ class TextRenderTest < ViewControllerTest
   if Rails::VERSION::MAJOR.to_i == 3 && Rails::VERSION::MINOR.to_i == 0
     test "should not instrument rendering of text" do
       get :text_render
-      sample = NewRelic::Agent.agent.transaction_sampler.samples.last
+      sample = NewRelic::Agent.agent.transaction_sampler.last_sample
       assert_equal [], sample.root_segment.called_segments.first.called_segments
     end
   else
     test "should create a metric for the rendered text" do
       get :text_render
-      sample = NewRelic::Agent.agent.transaction_sampler.samples.last
+      sample = NewRelic::Agent.agent.transaction_sampler.last_sample
       text_segment = sample.root_segment.called_segments.first.called_segments.first
       assert_equal 'View/text template/Rendering', text_segment.metric_name
     end
@@ -157,7 +157,7 @@ end
 class InlineTemplateRenderTest < ViewControllerTest
   test "should create a metric for the rendered inline template" do
     get :inline_render
-    sample = NewRelic::Agent.agent.transaction_sampler.samples.last
+    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
     text_segment = sample.root_segment.called_segments.first.called_segments.first
     assert_equal 'View/inline template/Rendering', text_segment.metric_name
   end
@@ -166,26 +166,25 @@ end
 class HamlRenderTest < ViewControllerTest
   test "should create a metric for the rendered haml template" do
     get :haml_render
-    sample = NewRelic::Agent.agent.transaction_sampler.samples.last
+    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
     text_segment = sample.root_segment.called_segments.first.called_segments.first
     assert_equal 'View/views/haml_view.html.haml/Rendering', text_segment.metric_name
   end
 end
 
 class MissingTemplateTest < ViewControllerTest
-  # Rails 3.0 has different behavior for rendering an empty array.  We're okay with this.
-  if Rails::VERSION::MAJOR.to_i == 3 && Rails::VERSION::MINOR.to_i == 0
-    test "should create an proper metric when the template is unknown" do
-      get :no_template
-      sample = NewRelic::Agent.agent.transaction_sampler.samples.last
-      text_segment = sample.root_segment.called_segments.first.called_segments.first
+  test "should create an proper metric when the template is unknown" do
+    get :no_template
+    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+    text_segment = sample.root_segment.called_segments.first.called_segments.first
+
+    # Different versions have significant difference in handling, but we're
+    # happy enough with what each of them does in the unknown case
+    if Rails::VERSION::MAJOR.to_i == 3 && Rails::VERSION::MINOR.to_i == 0
       assert_nil text_segment
-    end
-  else
-    test "should create an proper metric when the template is unknown" do
-      get :no_template
-      sample = NewRelic::Agent.agent.transaction_sampler.samples.last
-      text_segment = sample.root_segment.called_segments.first.called_segments.first
+    elsif Rails::VERSION::MAJOR.to_i == 3
+      assert_equal 'View/collection/Partial', text_segment.metric_name
+    else
       assert_equal 'View/(unknown)/Partial', text_segment.metric_name
     end
   end
@@ -194,7 +193,7 @@ end
 class CollectionTemplateTest < ViewControllerTest
   test "should create a proper metric when we render a collection" do
     get :collection_render
-    sample = NewRelic::Agent.agent.transaction_sampler.samples.last
+    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
     text_segment = sample.root_segment.called_segments.first.called_segments.first
     assert_equal "View/foos/_foo.html.haml/Partial", text_segment.metric_name
   end
@@ -204,7 +203,7 @@ class UninstrumentedRendersTest < ViewControllerTest
   [:js_render, :xml_render, :proc_render, :json_render ].each do |action|
     test "should not instrument rendering of #{action.inspect}" do
       get action
-      sample = NewRelic::Agent.agent.transaction_sampler.samples.last
+      sample = NewRelic::Agent.agent.transaction_sampler.last_sample
       assert_equal [], sample.root_segment.called_segments.first.called_segments
     end
   end
@@ -213,7 +212,7 @@ end
 class FileRenderTest < ViewControllerTest
   test "should create a metric for rendered file that does not include the filename so it doesn't metric explode" do
     get :file_render
-    sample = NewRelic::Agent.agent.transaction_sampler.samples.last
+    sample = NewRelic::Agent.agent.transaction_sampler.last_sample
     text_segment = sample.root_segment.called_segments.first.called_segments.first
     assert_equal 'View/file/Rendering', text_segment.metric_name
   end

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

@@ -106,16 +106,6 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     end
   end
 
-  def test_configure_transaction_tracer_with_random_sampling
-    with_config(:'transaction_tracer.transaction_threshold' => 5,
-                :'transaction_tracer.random_sample' => true) do
-      sample = make_sql_transaction
-      @transaction_sampler.store_sample(sample)
-
-      assert_equal sample, @transaction_sampler.instance_variable_get(:@random_sample)
-    end
-  end
-
   def test_configure_transaction_tracer_positive
     with_config(:'transaction_tracer.enabled' => true) do
       assert @transaction_sampler.enabled?

data/test/new_relic/agent/agent_test.rb

@@ -3,7 +3,6 @@
 # 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/commands/thread_profiler'
 
 module NewRelic
   module Agent
@@ -17,23 +16,6 @@ module NewRelic
         @agent.stubs(:start_worker_thread)
       end
 
-      #
-      # Helpers
-      #
-
-      def with_profile(opts)
-        profile = NewRelic::Agent::Threading::ThreadProfile.new(create_agent_command)
-        profile.aggregate(["chunky.rb:42:in `bacon'"], profile.traces[:other])
-        profile.instance_variable_set(:@finished, opts[:finished])
-
-        @agent.thread_profiler.instance_variable_set(:@profile, profile)
-        profile
-      end
-
-      #
-      # Tests
-      #
-
       def test_after_fork_reporting_to_channel
         @agent.stubs(:connected?).returns(true)
         @agent.after_fork(:report_to_channel => 123)
@@ -105,7 +87,10 @@ module NewRelic
         with_config(:'transaction_tracer.explain_threshold' => 2,
                     :'transaction_tracer.explain_enabled' => true,
                     :'transaction_tracer.record_sql' => 'raw') do
-          trace = stub('transaction trace', :force_persist => true,
+          trace = stub('transaction trace',
+                       :duration => 2.0, :threshold => 1.0,
+                       :transaction_name => nil,
+                       :force_persist => true,
                        :truncate => 4000)
           trace.expects(:prepare_to_send).with(:record_sql => :raw,
                                                :explain_sql => 2,
@@ -115,30 +100,6 @@ module NewRelic
         end
       end
 
-      def test_graceful_shutdown_ends_thread_profiling
-        @agent.thread_profiler.expects(:stop).once
-        @agent.stubs(:connected?).returns(true)
-        @agent.send(:graceful_disconnect)
-      end
-
-      def test_harvest_and_send_thread_profile
-        profile = with_profile(:finished => true)
-        @agent.service.expects(:profile_data).with(any_parameters)
-        @agent.send(:harvest_and_send_thread_profile, false)
-      end
-
-      def test_harvest_and_send_thread_profile_when_not_finished
-        with_profile(:finished => false)
-        @agent.service.expects(:profile_data).never
-        @agent.send(:harvest_and_send_thread_profile, false)
-      end
-
-      def test_harvest_and_send_thread_profile_when_not_finished_but_disconnecting
-        profile = with_profile(:finished => false)
-        @agent.service.expects(:profile_data).with(any_parameters)
-        @agent.send(:harvest_and_send_thread_profile, true)
-      end
-
       def test_harvest_timeslice_data
         assert_equal({}, @agent.send(:harvest_timeslice_data),
                      'should return timeslice data')
@@ -176,7 +137,13 @@ module NewRelic
 
       def test_handle_for_agent_commands
         @agent.service.expects(:get_agent_commands).returns([]).once
-        @agent.send :handle_agent_commands
+        @agent.send :check_for_and_handle_agent_commands
+      end
+
+      def test_harvest_and_send_for_agent_commands
+        @agent.service.expects(:profile_data).with(any_parameters)
+        @agent.agent_command_router.stubs(:harvest_data_to_send).returns({:profile_data => Object.new})
+        @agent.send :harvest_and_send_for_agent_commands
       end
 
       def test_merge_data_from_empty
@@ -257,6 +224,22 @@ module NewRelic
         assert_equal 0, @agent.stats_engine.get_stats("Errors/all").call_count
       end
 
+      def test_harvest_and_send_analytic_event_data_merges_in_samples_on_failure
+        service = @agent.service
+        request_sampler = @agent.instance_variable_get(:@request_sampler)
+        samples = [mock('some analytics event')]
+
+        request_sampler.expects(:harvest).returns(samples)
+        request_sampler.expects(:merge).with(samples)
+
+        # simulate a failure in transmitting analytics events
+        service.stubs(:analytic_event_data).raises(StandardError.new)
+
+        assert_raises(StandardError) do
+          @agent.send(:harvest_and_send_analytic_event_data)
+        end
+      end
+
       def test_connect_retries_on_timeout
         service = @agent.service
         def service.connect(opts={})

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -15,7 +15,6 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     NewRelic::Agent.manual_start
     @config = {
       :beacon                 => 'beacon',
-      :disable_mobile_headers => false,
       :browser_key            => 'browserKey',
       :application_id         => '5, 6', # collector can return app multiple ids
       :'rum.enabled'          => true,
@@ -312,46 +311,6 @@ var e=document.createElement("script");'
     assert_equal Base64.encode64(text).gsub("\n", ''), unoutput
   end
 
-  def test_no_mobile_response_header_if_no_mobile_request_header_given
-    request = Rack::Request.new({})
-    response = Rack::Response.new
-
-    NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
-    assert_nil response['X-NewRelic-Beacon-Url']
-  end
-
-  def test_no_mobile_response_header_if_mobile_request_header_is_false
-    request = Rack::Request.new('HTTP_X_NEWRELIC_MOBILE_TRACE' => 'false')
-    response = Rack::Response.new
-
-    NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
-    assert_nil response['X-NewRelic-Beacon-Url']
-  end
-
-  def test_place_beacon_url_header_when_given_mobile_request_header
-    response = mobile_transaction
-    assert_equal('http://beacon/mobile/1/browserKey',
-                 response['X-NewRelic-Beacon-Url'])
-  end
-
-  def test_place_beacon_url_header_when_given_mobile_request_header_with_https
-    request = Rack::Request.new('X_NEWRELIC_MOBILE_TRACE' => 'true',
-                                'rack.url_scheme' => 'https')
-    response = mobile_transaction(request)
-    assert_equal('https://beacon/mobile/1/browserKey',
-                 response['X-NewRelic-Beacon-Url'])
-  end
-
-  def test_place_beacon_payload_head_when_given_mobile_request_header
-    Time.stubs(:now).returns(Time.at(6))
-    response = mobile_transaction
-    txn_name = obfuscate(NewRelic::Agent.instance.beacon_configuration,
-                         browser_monitoring_transaction_name)
-    expected_payload = %|["5, 6","#{txn_name}",#{current_timings.queue_time_in_millis},#{current_timings.app_time_in_millis}]|
-
-    assert_equal expected_payload, response['X-NewRelic-App-Server-Metrics'].strip
-  end
-
   def test_freezes_transaction_name_when_footer_is_written
     with_config(:license_key => 'a' * 13) do
       in_transaction do
@@ -361,15 +320,4 @@ var e=document.createElement("script");'
       end
     end
   end
-
-  def mobile_transaction(request=nil)
-    request ||= Rack::Request.new('X-NewRelic-Mobile-Trace' => 'true')
-    response = Rack::Response.new
-    txn = NewRelic::Agent::Transaction.new
-    txn.name = 'a transaction name'
-    txn.start_time = Time.at(5)
-    NewRelic::Agent::TransactionState.get.transaction = txn
-    NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
-    response
-  end
 end

data/test/new_relic/agent/commands/agent_command_router_test.rb

@@ -4,6 +4,7 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 require 'new_relic/agent/commands/agent_command_router'
+require 'new_relic/agent/commands/xray_session'
 
 class AgentCommandRouterTest < Test::Unit::TestCase
 
@@ -36,46 +37,52 @@ class AgentCommandRouterTest < Test::Unit::TestCase
     NewRelic::Agent.agent.stubs(:service).returns(@service)
     @calls = []
 
-    @agent_commands = NewRelic::Agent::Commands::AgentCommandRouter.new(nil)
+    @agent_commands = NewRelic::Agent::Commands::AgentCommandRouter.new
     @agent_commands.handlers["bazzle"] = Proc.new { |args| handle_bazzle_command(args) }
     @agent_commands.handlers["boom"]   = Proc.new { |args| handle_boom_command(args) }
   end
 
-  def test_handle_agent_commands_dispatches_command
+  def teardown
+    agent_commands.backtrace_service.worker_thread.join if agent_commands.backtrace_service.worker_thread
+  end
+
+  # General command routing
+
+  def test_check_for_and_handle_agent_commands_dispatches_command
     service.stubs(:get_agent_commands).returns([BAZZLE])
     service.stubs(:agent_command_results)
 
-    agent_commands.handle_agent_commands
+    agent_commands.check_for_and_handle_agent_commands
 
     assert_equal [DEFAULT_ARGS], calls
   end
 
-  def test_handle_agent_commands_generates_results
+  def test_check_for_and_handle_agent_commands_generates_results
     service.stubs(:get_agent_commands).returns([BAZZLE])
     service.expects(:agent_command_results).with({ BAZZLE_ID.to_s => {} })
 
-    agent_commands.handle_agent_commands
+    agent_commands.check_for_and_handle_agent_commands
   end
 
-  def test_handle_agent_commands_dispatches_with_error
+  def test_check_for_and_handle_agent_commands_dispatches_with_error
     service.stubs(:get_agent_commands).returns([BOOM])
     service.expects(:agent_command_results).with({ BOOM_ID.to_s => { "error" => "BOOOOOM" }})
 
-    agent_commands.handle_agent_commands
+    agent_commands.check_for_and_handle_agent_commands
   end
 
-  def test_handle_agent_commands_allows_multiple
+  def test_check_for_and_handle_agent_commands_allows_multiple
     service.stubs(:get_agent_commands).returns([BAZZLE, BOOM])
     service.expects(:agent_command_results).with({ BAZZLE_ID.to_s => {},
                                                    BOOM_ID.to_s => { "error" => "BOOOOOM" }})
-    agent_commands.handle_agent_commands
+    agent_commands.check_for_and_handle_agent_commands
   end
 
-  def test_handle_agent_commands_doesnt_call_results_if_no_commands
+  def test_check_for_and_handle_agent_commands_doesnt_call_results_if_no_commands
     service.stubs(:get_agent_commands).returns([])
     service.expects(:agent_command_results).never
 
-    agent_commands.handle_agent_commands
+    agent_commands.check_for_and_handle_agent_commands
   end
 
   def test_unrecognized_commands
@@ -84,7 +91,117 @@ class AgentCommandRouterTest < Test::Unit::TestCase
 
     expects_logging(:debug, regexp_matches(/unrecognized/i))
 
-    agent_commands.handle_agent_commands
+    agent_commands.check_for_and_handle_agent_commands
+  end
+
+  # Start/stop X-Ray tests
+
+  def test_empty_agent_commands_stops_running_xray
+    start_xray_session(123)
+
+    service.stubs(:get_agent_commands).returns([])
+    agent_commands.check_for_and_handle_agent_commands
+
+    assert_false agent_commands.xray_session_collection.include?(123)
+  end
+
+  # Harvesting tests
+
+  if NewRelic::Agent::Threading::BacktraceService.is_supported?
+
+    DISCONNECTING = true
+    NOT_DISCONNECTING = false
+
+    def test_harvest_data_to_send_not_started
+      result = agent_commands.harvest_data_to_send(NOT_DISCONNECTING)
+      assert_equal({}, result)
+    end
+
+    def test_harvest_data_to_send_with_profile_in_progress
+      start_profile('duration' => 1.0)
+
+      result = agent_commands.harvest_data_to_send(NOT_DISCONNECTING)
+      assert_equal({}, result)
+    end
+
+    def test_harvest_data_to_send_with_profile_completed
+      start_profile('duration' => 1.0)
+
+      advance_time(1.1)
+      result = agent_commands.harvest_data_to_send(NOT_DISCONNECTING)
+
+      assert_not_nil result[:profile_data]
+    end
+
+    def test_can_stop_multiple_times_safely
+      start_profile('duration' => 1.0)
+
+      advance_time(1.1)
+      agent_commands.thread_profiler_session.stop(true)
+
+      result = agent_commands.harvest_data_to_send(NOT_DISCONNECTING)
+      assert_not_nil result[:profile_data]
+    end
+
+    def test_transmits_after_forced_stop
+      start_profile('duration' => 1.0)
+
+      agent_commands.thread_profiler_session.stop(true)
+
+      result = agent_commands.harvest_data_to_send(NOT_DISCONNECTING)
+      assert_not_nil result[:profile_data]
+    end
+
+    def test_harvest_data_to_send_with_no_profile_disconnecting
+      result = agent_commands.harvest_data_to_send(DISCONNECTING)
+      assert_nil result[:profile_data]
+    end
+
+    def test_harvest_data_to_send_with_profile_in_progress_but_disconnecting
+      start_profile('duration' => 1.0)
+
+      result = agent_commands.harvest_data_to_send(DISCONNECTING)
+      assert_not_nil result[:profile_data]
+    end
+
+    def test_harvest_data_to_send_with_xray_sessions_in_progress
+      start_xray_session(123)
+      start_xray_session(456)
+
+      sample_on_profiles
+
+      result = agent_commands.harvest_data_to_send(NOT_DISCONNECTING)
+
+      assert_equal 2, result[:profile_data].length
+    end
+
+    def test_harvest_data_to_send_with_xray_sessions_and_thread_profile_in_progress
+      start_xray_session(123)
+      start_xray_session(456)
+
+      start_profile('duration' => 1.0)
+
+      sample_on_profiles
+
+      result = agent_commands.harvest_data_to_send(NOT_DISCONNECTING)
+
+      assert_equal 2, result[:profile_data].length
+    end
+
+    def test_harvest_data_to_send_with_xray_sessions_and_completed_thread_profile
+      start_xray_session(123)
+      start_xray_session(456)
+
+      start_profile('duration' => 1.0)
+
+      sample_on_profiles
+      advance_time(1.1)
+
+      result = agent_commands.harvest_data_to_send(NOT_DISCONNECTING)
+
+      assert_equal 3, result[:profile_data].length
+    end
+
   end
 
   # Helpers
@@ -96,4 +213,25 @@ class AgentCommandRouterTest < Test::Unit::TestCase
   def handle_boom_command(command)
     raise NewRelic::Agent::Commands::AgentCommandRouter::AgentCommandError.new("BOOOOOM")
   end
+
+  def start_profile(args={})
+    freeze_time
+    agent_commands.backtrace_service.worker_loop.stubs(:run)
+    agent_commands.thread_profiler_session.start(create_agent_command(args))
+  end
+
+  def start_xray_session(id)
+    args = { 'x_ray_id' => id, 'key_transaction_name' => "txn_#{id}" }
+    session = NewRelic::Agent::Commands::XraySession.new(args)
+
+    agent_commands.backtrace_service.worker_loop.stubs(:run)
+    agent_commands.xray_session_collection.add_session(session)
+  end
+
+  def sample_on_profiles
+    agent_commands.backtrace_service.profiles.each do |(_, profile)|
+      profile.aggregate([], :request, Thread.current)
+    end
+  end
+
 end