newrelic_rpm 3.6.7.159 → 3.6.8.164

data/test/new_relic/agent/transaction_test.rb

@@ -168,6 +168,30 @@ class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
     )
   end
 
+  def test_stop_sets_name
+    NewRelic::Agent::Transaction.start(:controller)
+    txn = NewRelic::Agent::Transaction.stop('new_name')
+    assert_equal 'new_name', txn.name
+  end
+
+  def test_name_is_unset_if_nil
+    txn = NewRelic::Agent::Transaction.new
+    txn.name = nil
+    assert !txn.name_set?
+  end
+
+  def test_name_is_unset_if_unknown
+    txn = NewRelic::Agent::Transaction.new
+    txn.name = NewRelic::Agent::UNKNOWN_METRIC
+    assert !txn.name_set?
+  end
+
+  def test_name_set_if_anything_else
+    txn = NewRelic::Agent::Transaction.new
+    txn.name = "anything else"
+    assert txn.name_set?
+  end
+
   def test_start_adds_controller_context_to_txn_stack
     NewRelic::Agent::Transaction.start(:controller)
     assert_equal 1, NewRelic::Agent::Transaction.stack.size
@@ -198,9 +222,12 @@ class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
   end
 
   def test_end_fires_a_transaction_finished_event
-    name, timestamp, duration = nil
-    NewRelic::Agent.subscribe(:transaction_finished) do |*args|
-      name, timestamp, duration = *args
+    name, timestamp, duration, type = nil
+    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
+      name = payload[:name]
+      timestamp = payload[:start_timestamp]
+      duration = payload[:duration]
+      type = payload[:type]
     end
 
     start_time = freeze_time
@@ -213,12 +240,13 @@ class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
     assert_equal 'Controller/foo/1/bar/22', name
     assert_equal start_time.to_f, timestamp
     assert_equal 5.0, duration
+    assert_equal :controller, type
   end
 
   def test_end_fires_a_transaction_finished_event_with_overview_metrics
     options = nil
-    NewRelic::Agent.subscribe(:transaction_finished) do |_, _, _, opts|
-      options = opts
+    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
+      options = payload[:overview_metrics]
     end
 
     NewRelic::Agent::Transaction.start(:controller)

data/test/new_relic/agent/worker_loop_test.rb

@@ -7,7 +7,6 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
   def setup
     @worker_loop = NewRelic::Agent::WorkerLoop.new
-    @test_start_time = Time.now
   end
 
   def test_add_task
@@ -20,18 +19,18 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
   end
 
   def test_with_duration
-    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 0.1)
+    freeze_time
 
-    # Advance in small increments vs our period so time will pass over the
-    # nasty multiple calls to Time.now that WorkerLoop makes
-    Time.stubs(:now).returns(*ticks(0, 0.12, 0.005))
+    period = 5.0
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 16.0)
 
-    count = 0
-    worker_loop.run(0.04) do
-      count += 1
+    def worker_loop.sleep(duration)
+      advance_time(duration)
     end
 
-    assert_equal 2, count
+    count = 0
+    worker_loop.run(period) { count += 1 }
+    assert_equal 3, count
   end
 
   def test_duration_clock_starts_with_run
@@ -62,13 +61,13 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     assert done
   end
 
-  class BadBoy < StandardError; end
+  class Supernova < StandardError; end
 
   def test_task_error__exception
     expects_logging(:error, any_parameters)
     @worker_loop.run(0) do
       @worker_loop.stop
-      raise BadBoy, "oops"
+      raise Supernova, "oops"
     end
   end
 
@@ -81,6 +80,29 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     end
   end
 
+  def test_worker_loop_propagates_errors_given_the_option
+    @worker_loop = NewRelic::Agent::WorkerLoop.new(
+      :limit => 2,
+      :propagate_errors => true
+    )
+
+    assert_raises Supernova do
+      @worker_loop.run(0) do
+        raise Supernova
+      end
+    end
+  end
+
+  def test_dynamically_adjusts_the_period_once_the_loop_has_been_started
+    freeze_time
+
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 2)
+
+    worker_loop.expects(:sleep).with(5.0)
+    worker_loop.expects(:sleep).with(7.0)
+    worker_loop.run(5.0) { advance_time(5.0); worker_loop.period = 7.0 }
+  end
+
   def ticks(start, finish, step)
     (start..finish).step(step).map{|i| Time.at(i)}
   end

data/test/new_relic/coerce_test.rb

@@ -31,6 +31,19 @@ class CoerceTest < Test::Unit::TestCase
     int("not valid", "HERE")
   end
 
+  def test_int_coerce_or_nil
+    assert_equal 1, int_or_nil(1)
+    assert_equal 1, int_or_nil("1")
+    assert_equal 1, int_or_nil(1.0)
+    assert_equal 1, int_or_nil(Rational(1, 1))
+    assert_equal nil, int_or_nil("invalid")
+    assert_equal nil, int_or_nil(nil)
+  end
+
+  def test_int_or_nil_coerce_logs_with_context
+    expects_logging(:warn, all_of(includes("HERE"), includes("Integer")), anything)
+    int_or_nil("not valid", "HERE")
+  end
 
   def test_float_coerce
     assert_equal 1.0, float(1.0)

data/test/new_relic/fake_collector.rb

@@ -23,6 +23,7 @@ module NewRelic
         'get_redirect_host'       => [200, {'return_value' => 'localhost'}],
         'connect'                 => [200, {'return_value' => {"agent_run_id" => agent_run_id}}],
         'get_agent_commands'      => [200, {'return_value' => []}],
+        'agent_command_results'   => [200, {'return_value' => []}],
         'metric_data'             => [200, {'return_value' => [[{'name' => 'Some/Metric/Spec'}, 1]]}],
         'sql_trace_data'          => [200, {'return_value' => nil}],
         'transaction_sample_data' => [200, {'return_value' => nil}],
@@ -173,10 +174,10 @@ module NewRelic
     end
 
     class ProfileDataPost < AgentPost
-      attr_accessor :poll_count, :traces
+      attr_accessor :sample_count, :traces
       def initialize(opts={})
         super
-        @poll_count = @body[1][0][3]
+        @sample_count = @body[1][0][3]
         @body[1][0][4] = unblob(@body[1][0][4]) if @format == :json
         @traces = @body[1][0][4]
       end
@@ -190,13 +191,35 @@ module NewRelic
     end
 
     class TransactionSampleDataPost < AgentPost
+      class SubmittedTransactionTrace
+        def initialize(body)
+          @body = body
+        end
+
+        def metric_name
+          @body[2]
+        end
+
+        def uri
+          @body[3]
+        end
+
+        def xray_id
+          @body[8]
+        end
+      end
+
       def initialize(opts={})
         super
         @body[4] = unblob(@body[4]) if @format == :json
       end
 
+      def samples
+        @samples ||= @body[1].map { |s| SubmittedTransactionTrace.new(s) }
+      end
+
       def metric_name
-        @body[1][0][2]
+        samples.first.metric_name
       end
     end
     class AnalyticEventDataPost < AgentPost

data/test/new_relic/multiverse_helpers.rb

@@ -70,6 +70,8 @@ module MultiverseHelpers
       Thread.current[key] = nil
     end
 
+    NewRelic::Agent.instance.transaction_sampler.reset!
+
     NewRelic::Agent.shutdown
   end
 

data/test/new_relic/rack/browser_monitoring_test.rb

@@ -72,6 +72,7 @@ EOL
     mocha_teardown
     TestApp.doc = nil
     NewRelic::Agent.config.remove_config(@config)
+    NewRelic::Agent.agent.transaction_sampler.reset!
   end
 
   def test_make_sure_header_is_set
@@ -161,6 +162,17 @@ EOL
       assert(last_response.body.include?(guid), last_response.body)
     end
   end
+
+  def test_calculate_content_length_accounts_for_multibyte_characters_for_186
+    String.stubs(:respond_to?).with(:bytesize).returns(false)
+    browser_monitoring = NewRelic::Rack::BrowserMonitoring.new(mock('app'))
+    assert_equal 24, browser_monitoring.calculate_content_length("猿も木から落ちる")
+  end
+
+  def test_calculate_content_length_accounts_for_multibyte_characters_for_modern_ruby
+    browser_monitoring = NewRelic::Rack::BrowserMonitoring.new(mock('app'))
+    assert_equal 18, browser_monitoring.calculate_content_length("七転び八起き")
+  end
 end
 else
   puts "Skipping tests in #{__FILE__} because Rails is unavailable (or too old)"

data/test/new_relic/rack/developer_mode_test.rb

@@ -44,7 +44,7 @@ class DeveloperModeTest < Test::Unit::TestCase
   end
 
   def test_show_sample_summary_displays_sample_details
-    get "/newrelic/show_sample_summary?id=#{@sampler.samples[0].sample_id}"
+    get "/newrelic/show_sample_summary?id=#{@sampler.dev_mode_sample_buffer.samples[0].sample_id}"
 
     assert last_response.ok?
     assert last_response.body.include?('/here')
@@ -53,7 +53,7 @@ class DeveloperModeTest < Test::Unit::TestCase
   end
 
   def test_explain_sql_displays_query_plan
-    sample = @sampler.samples[0]
+    sample = @sampler.dev_mode_sample_buffer.samples[0]
     sql_segment = sample.sql_segments[0]
     explain_results = NewRelic::Agent::Database.process_resultset(example_explain_as_hashes)
 

data/test/new_relic/transaction_sample_test.rb

@@ -178,6 +178,13 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
     assert(s.timestamp.instance_of?(Float), "s.timestamp should be a Float, but is #{s.timestamp.class.inspect}")
   end
 
+  def test_xray_session_id
+    @t.xray_session_id = 123
+    s = @t.prepare_to_send
+    assert_equal(123, s.xray_session_id)
+  end
+
+
   def test_count_segments
     transaction = run_sample_trace_on(NewRelic::Agent::TransactionSampler.new) do |sampler|
       sampler.notice_push_scope "level0"
@@ -221,21 +228,31 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
                       (@t.duration * 1000).round,
                       @t.params[:path], @t.params[:uri],
                       trace_tree,
-                      @t.guid, nil, !!@t.force_persist]
+                      @t.guid, nil, !!@t.force_persist, @t.xray_session_id]
 
     assert_equal expected_array, @t.to_collector_array(@marshaller.default_encoder)
   end
 
+  FORCE_PERSIST_POSITION = 7
+
+  def test_to_collector_array_forces_xrays
+    @t.force_persist = false
+    @t.xray_session_id = 123
+    result = @t.to_collector_array(@marshaller.default_encoder)
+    assert_equal true, result[FORCE_PERSIST_POSITION]
+  end
+
   def test_to_collector_array_with_bad_values
     transaction = NewRelic::TransactionSample.new(nil)
     transaction.root_segment.end_trace(Rational(10, 1))
+    transaction.xray_session_id = "booooooo"
 
     expected = [
       0, 10_000,
       nil, nil,
       trace_tree(transaction),
       transaction.guid,
-      nil, false]
+      nil, false, nil]
 
     assert_equal expected, transaction.to_collector_array(@marshaller.default_encoder)
   end

data/test/performance/lib/performance/console_reporter.rb

@@ -24,7 +24,7 @@ module Performance
         puts "#{result.identifier}: #{result.elapsed} s"
         unless @options[:brief]
           result.measurements.each do |key, value|
-            puts "  #{key}: #{value}"
+            puts "  %s: %g" % [key, value]
           end
         end
         unless result.artifacts.empty?

data/test/performance/lib/performance/test_case.rb

@@ -51,12 +51,16 @@ module Performance
       result = Result.new(self.class, name)
       begin
         with_callbacks(name) do
-          result.timer.measure do
-            self.send(name)
+          if self.method(name).arity == 0
+            result.timer.measure do
+              self.send(name)
+            end
+          else
+            self.send(name, result.timer)
           end
           result
         end
-      rescue => e
+      rescue StandardError, LoadError => e
         result.exception = e
       end
       result

data/test/performance/script/runner

@@ -22,6 +22,9 @@ parser = OptionParser.new do |opts|
   opts.on("-i", "--instrumentor=NAME", "Use the named instrumentor") do |name|
     options[:instrumentors] = [name]
   end
+  opts.on("-s", "--suite=NAME", "Filter to just run a single test suite") do |name|
+    options[:suite] = name
+  end
   opts.on("-n", "--name=NAME", "Filter tests to those matching NAME") do |name|
     options[:name] = name
   end

data/test/performance/suites/thread_profiling.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+class ThreadProfiling < Performance::TestCase
+  def recurse(n, final)
+    if n == 0
+      final.call
+    else
+      recurse(n-1, final)
+    end
+  end
+
+  def block
+    @mutex.synchronize do
+      @cvar.wait(@mutex)
+    end
+  end
+
+  def setup
+    require 'new_relic/agent/threading/backtrace_service'
+
+    @nthreads = 16
+
+    @mutex = Mutex.new
+    @cvar = ConditionVariable.new
+    @threadq = Queue.new
+    @threads = []
+
+    @nthreads.times do
+      @threads << Thread.new do
+        @threadq << self
+        transaction_state = NewRelic::Agent::TransactionState.get
+        def transaction_state.in_request_transaction?; true; end
+        recurse(50, method(:block))
+      end
+    end
+
+    # Ensure that all threads have had a chance to start up
+    started_count = 0
+    while started_count < @nthreads do
+      @threadq.pop
+      started_count += 1
+    end
+
+    @service = NewRelic::Agent::Threading::BacktraceService.new
+    @worker_loop = @service.worker_loop
+    def @worker_loop.run; end # we want to drive it manually
+  end
+
+  def teardown
+    @cvar.broadcast
+    @threads.each(&:join)
+  end
+
+  def test_gather_backtraces(timer)
+    @service.subscribe(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
+    timer.measure do
+      (iterations / 10).times do
+        @service.poll
+      end
+    end
+    @service.unsubscribe(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
+  end
+
+  def test_gather_backtraces_subscribed(timer)
+    @service.subscribe('eagle')
+    timer.measure do
+      (iterations / 10).times do
+        t0 = Time.now.to_f
+        @service.poll
+        payload = {
+          :name => 'eagle',
+          :start_timestamp => t0,
+          :duration => Time.now.to_f-t0,
+          :thread => @threads.sample
+        }
+        @service.on_transaction_finished(payload)
+      end
+    end
+    @service.unsubscribe('eagle')
+  end
+end