wd_newrelic_rpm 3.5.6 → 3.5.8

data/test/multiverse/suites/agent_only/start_up_test.rb

@@ -16,6 +16,6 @@ class StartUpTest < Test::Unit::TestCase
 
     jruby_noise.each {|noise| output.gsub!(noise, "")}
 
-    assert_equal '', output
+    assert_equal '', output.chomp
   end
 end

data/test/multiverse/suites/agent_only/thread_profiling_test.rb

@@ -13,6 +13,7 @@ class ThreadProfilingTest < Test::Unit::TestCase
 
     NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
     NewRelic::Agent.manual_start(:'thread_profiler.enabled' => true)
+    NewRelic::Agent.instance.service.request_timeout = 0.5
 
     @agent = NewRelic::Agent.instance
     @thread_profiler = @agent.thread_profiler
@@ -51,11 +52,11 @@ class ThreadProfilingTest < Test::Unit::TestCase
 
   def test_thread_profiling
     @agent.send(:check_for_agent_commands)
-    sleep(1)
-    NewRelic::Agent.shutdown
+
+    let_it_finish
 
     profile_data = $collector.calls_for('profile_data')[0]
-    assert_equal(666, profile_data[0])
+    assert_equal('666', profile_data.run_id)
 
     poll_count = profile_data[1][0][3]
     assert poll_count > 25, "Expected poll_count > 25, but was #{poll_count}"
@@ -67,15 +68,25 @@ class ThreadProfilingTest < Test::Unit::TestCase
     $collector.mock['get_agent_commands'] = [200, {'return_value' => STOP_COMMAND}]
     @agent.send(:check_for_agent_commands)
 
-    sleep(0.1)
-    NewRelic::Agent.shutdown
+    let_it_finish
 
     profile_data = $collector.calls_for('profile_data')[0]
-    assert_equal(666, profile_data[0])
+    assert_equal('666', profile_data.run_id)
 
     poll_count = profile_data[1][0][3]
     assert poll_count < 10, "Expected poll_count < 10, but was #{poll_count}"
   end
+
+
+  def let_it_finish
+    Timeout.timeout(2) do
+      until @thread_profiler.finished?
+        sleep(0.1)
+      end
+    end
+
+    NewRelic::Agent.shutdown
+  end
 end
 end
 

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

@@ -85,22 +85,26 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
 
   def test_should_capture_error_raised_in_view
     get '/error/view_error'
-    assert_error_reported_once('this is an uncaught view error')
+    assert_error_reported_once('this is an uncaught view error',
+                               'Controller/error/view_error')
   end
 
   def test_should_capture_error_raised_in_controller
     get '/error/controller_error'
-    assert_error_reported_once('this is an uncaught controller error')
+    assert_error_reported_once('this is an uncaught controller error',
+                               'Controller/error/controller_error')
   end
 
   def test_should_capture_error_raised_in_model
     get '/error/model_error'
-    assert_error_reported_once('this is an uncaught model error')
+    assert_error_reported_once('this is an uncaught model error',
+                               'Controller/error/model_error')
   end
 
   def test_should_capture_noticed_error_in_controller
     get '/error/noticed_error'
-    assert_error_reported_once('this error should be noticed')
+    assert_error_reported_once('this error should be noticed',
+                               'Controller/error/noticed_error')
   end
 
   # Important choice of controllor_error, since this goes through both the
@@ -160,17 +164,25 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
 
  protected
 
-  def assert_errors_reported(message, queued_count, total_count=queued_count)
+  def assert_errors_reported(message, queued_count, total_count=queued_count, txn_name=nil)
     error_count = NewRelic::Agent::Agent.instance.stats_engine.get_stats("Errors/all")
-    assert_equal total_count, error_count.call_count
+    assert_equal(total_count, error_count.call_count,
+                 'Incorrect call count on Errors/all')
+
+    if txn_name
+      error_count = NewRelic::Agent::Agent.instance.stats_engine \
+        .get_stats("Errors/#{txn_name}")
+      assert_equal(total_count, error_count.call_count,
+                   "Incorrect call count on Errors/#{txn_name}")
+    end
 
     assert_equal(queued_count,
       @error_collector.errors.select{|error| error.message == message}.size,
       "Wrong number of errors with message '#{message} found'")
   end
 
-  def assert_error_reported_once(message)
-    assert_errors_reported(message, 1)
+  def assert_error_reported_once(message, txn_name=nil)
+    assert_errors_reported(message, 1, 1, txn_name)
   end
 end
 

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

@@ -43,8 +43,8 @@ class QueueTimeTest < ActionDispatch::IntegrationTest
     assert extract_queue_time_from_response > 0, "Queue time was missing or zero"
   end
 
-  def get_queued(header="HTTP_X_QUEUE_START")
-    get('/queue/queued', nil, \
+  def get_queued(header="HTTP_X_REQUEST_START")
+    get('/queue/queued', nil,
         header => "t=#{(Time.now.to_i * 1_000_000) - 1_000}")
   end
 

data/test/multiverse/suites/resque/instrumentation_test.rb

@@ -17,6 +17,7 @@ class ResqueTest < Test::Unit::TestCase
     $collector.run(COLLECTOR_PORT)
     $redis.del('queue:resque_test')
     $redis.set('index_key', 0)
+    Resque::Stat.clear('processed')
     @pidfile = "resque_test.#{$$}.pid"
     JOB_COUNT.times do |i|
       Resque.enqueue(JobForTesting, 'index_key', i + 1)
@@ -40,7 +41,7 @@ class ResqueTest < Test::Unit::TestCase
   end
 
   def start_worker_child(env_vars=nil)
-    worker_cmd = "NEWRELIC_DISPATCHER=resque #{env_vars} QUEUE=* bundle exec rake resque:work"
+    worker_cmd = "#{env_vars} QUEUE=* bundle exec rake resque:work"
     @worker_pid = Process.fork
     Process.exec(worker_cmd) if @worker_pid.nil?
   end
@@ -52,7 +53,7 @@ class ResqueTest < Test::Unit::TestCase
 
   def start_worker_background(env_vars=nil)
     worker_cmd = "PIDFILE=#{@pidfile} TERM_CHILD=1 RESQUE_TERM_TIMEOUT=1 BACKGROUND=1 " +
-      "NEWRELIC_DISPATCHER=resque #{env_vars} QUEUE=* bundle exec rake resque:work"
+      "#{env_vars} QUEUE=* bundle exec rake resque:work"
     system(worker_cmd)
   end
 
@@ -89,7 +90,7 @@ class ResqueTest < Test::Unit::TestCase
   def wait_for_jobs
     time_for_jobs = 5
     begin
-      Timeout.timeout(time_for_jobs) { sleep(0.1) until Resque.info[:pending].zero? }
+      Timeout.timeout(time_for_jobs) { sleep(0.1) until Resque.info[:processed] == JOB_COUNT }
     rescue Timeout::Error => err
       raise err.exception("waiting #{time_for_jobs}s for completion of #{JOB_COUNT} jobs")
     end

data/test/multiverse/suites/sinatra/Envfile

@@ -5,9 +5,11 @@ end
 gemfile <<-RB
   gem 'sinatra', '1.3.3'
   gem 'rack-test', :require => 'rack/test'
+  gem 'mocha'
 RB
 
 gemfile <<-RB
   gem 'sinatra', '1.2.8'
   gem 'rack-test', :require => 'rack/test'
+  gem 'mocha'
 RB

data/test/multiverse/suites/sinatra/config/newrelic.yml

@@ -10,6 +10,7 @@ development:
   license_key: bootstrap_newrelic_admin_license_key_000
   developer_mode: false
   app_name: test
+  sync_startup: true
   host: 127.0.0.1
   api_host: 127.0.0.1
   port: <%= 30_000 + ($$ % 10_000) %>

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

@@ -42,14 +42,14 @@ class SinatraMetricExplosionTest < Test::Unit::TestCase
 
   def test_transaction_name_from_route
     get '/hello/world'
-    metric_names = ::NewRelic::Agent.agent.stats_engine.stats_hash.keys.map{|k| k.name}
+    metric_names = ::NewRelic::Agent.agent.stats_engine.metrics
     assert metric_names.include?('Controller/Sinatra/SinatraTestApp/GET hello/([^/?#]+)')
     assert metric_names.include?('Apdex/Sinatra/SinatraTestApp/GET hello/([^/?#]+)')
   end
 
   def test_transaction_name_from_path
     get '/wrong'
-    metric_names = ::NewRelic::Agent.agent.stats_engine.stats_hash.keys.map{|k| k.name}
+    metric_names = ::NewRelic::Agent.agent.stats_engine.metrics
     assert metric_names.include?('Controller/Sinatra/SinatraTestApp/GET (unknown)')
     assert metric_names.include?('Apdex/Sinatra/SinatraTestApp/GET (unknown)')
   end
@@ -61,8 +61,8 @@ class SinatraMetricExplosionTest < Test::Unit::TestCase
     get '/hello/isitmeyourelookingfor?'
     get '/another_controller'
 
-    metric_names = ::NewRelic::Agent.agent.stats_engine.stats_hash.keys.
-      map{|k| k.name} - ['CPU/User Time', "Middleware/all", "WebFrontend/QueueTime", "WebFrontend/WebServer/all"]
+    metric_names = ::NewRelic::Agent.agent.stats_engine.metrics
+    metric_names -= ['CPU/User Time', "Middleware/all", "WebFrontend/QueueTime", "WebFrontend/WebServer/all"]
     assert_equal 6, metric_names.size, "Explosion detected in: #{metric_names.inspect}"
   end
 
@@ -70,7 +70,7 @@ class SinatraMetricExplosionTest < Test::Unit::TestCase
     assert_nothing_raised do
       post '/some/garbage'
     end
-    metric_names = ::NewRelic::Agent.agent.stats_engine.stats_hash.keys.map{|k| k.name}
+    metric_names = ::NewRelic::Agent.agent.stats_engine.metrics
     assert metric_names.include?('Controller/Sinatra/SinatraTestApp/POST (unknown)')
     assert metric_names.include?('Apdex/Sinatra/SinatraTestApp/POST (unknown)')
   end

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

@@ -1,6 +1,10 @@
+require 'mocha'
 
 class SinatraRouteTestApp < Sinatra::Base
   configure do
+    # display exceptions so we see what's going on
+    disable :show_exceptions
+
     # create a condition (sintra's version of a before_filter) that returns the
     # value that was passed into it.
     set :my_condition do |boolean|
@@ -8,9 +12,6 @@ class SinatraRouteTestApp < Sinatra::Base
         halt 404 unless boolean
       end
     end
-
-    # treat errors like production for testing purposes
-    set :show_exceptions, false
   end
 
   get '/user/login' do
@@ -22,10 +23,37 @@ class SinatraRouteTestApp < Sinatra::Base
     "Welcome #{id}"
   end
 
-  get '/error' do
+  get '/raise' do
     raise "Uh-oh"
   end
 
+  # check that pass works properly
+  condition { pass { halt 418, "I'm a teapot." } }
+  get('/pass') { }
+
+  get '/pass' do
+    "I'm not a teapot."
+  end
+
+  class Error < StandardError; end
+  error(Error) { halt 200, 'nothing happened' }
+  condition { raise Error }
+  get('/error') { }
+
+  def perform_action_with_newrelic_trace(options)
+    $last_sinatra_route = options[:name]
+    super
+  end
+
+  get '/route/:name' do |name|
+    # usually this would be a db test or something
+    pass if name != 'match'
+    'first route'
+  end
+
+  get '/route/no_match' do
+    'second route'
+  end
 end
 
 class SinatraTest < Test::Unit::TestCase
@@ -57,16 +85,55 @@ class SinatraTest < Test::Unit::TestCase
   end
 
   def test_queue_time_headers_are_passed_to_agent
-    get '/user/login', {}, {"X-Request-Start" => 't=1234567890'}
-    metric_names = ::NewRelic::Agent.agent.stats_engine.stats_hash.keys.map{|k| k.name}
-    assert metric_names.include?("Middleware/all")
-    assert metric_names.include?("WebFrontend/QueueTime")
-    assert metric_names.include?("WebFrontend/WebServer/all")
-    assert ::NewRelic::Agent.agent.stats_engine.get_stats("WebFrontend/WebServer/all")
+    get '/user/login', {}, { 'HTTP_X_REQUEST_START' => 't=1360973845' }
+    assert ::NewRelic::Agent.agent.stats_engine.lookup_stats('WebFrontend/QueueTime')
   end
 
   def test_shown_errors_get_caught
+     get '/raise'
+     assert_equal 1, ::NewRelic::Agent.agent.error_collector.errors.size
+  end
+
+  def test_does_not_break_pass
+    get '/pass'
+    assert_equal 200, last_response.status
+    assert_equal "I'm not a teapot.", last_response.body
+  end
+
+  def test_does_not_break_error_handling
+    get '/error'
+    assert_equal 200, last_response.status
+    assert_equal "nothing happened", last_response.body
+  end
+
+  def test_sees_handled_error
     get '/error'
     assert_equal 1, ::NewRelic::Agent.agent.error_collector.errors.size
   end
+
+  def test_correct_pattern
+    get '/route/match'
+    assert_equal 'first route', last_response.body
+    assert_equal 'GET route/([^/?#]+)', $last_sinatra_route
+
+    get '/route/no_match'
+    assert_equal 'second route', last_response.body
+
+    # Ideally we could handle this assert, but we can't rename transactions
+    # in flight at this point. Once we get that ability, consider patching
+    # process_route to notify of route name changes.
+
+    # assert_equal 'GET route/no_match', $last_sinatra_route
+  end
+
+  def test_set_unknown_transaction_name_if_error_in_routing
+    ::NewRelic::Agent::Instrumentation::Sinatra::NewRelic \
+      .stubs(:http_verb).raises(StandardError.new('madness'))
+
+    get '/user/login'
+
+    metric_names = ::NewRelic::Agent.agent.stats_engine.metrics
+    assert(metric_names.include?('Controller/Sinatra/SinatraRouteTestApp/(unknown)'),
+           "#{metric_names} should include 'Controller/Sinatra/SinatraRouteTestApp/(unknown)'")
+  end
 end

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

@@ -181,7 +181,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     query_server_for_configuration
   end
 
-  def test_connect_to_server_gets_config_from_collector
+  def test_connect_gets_config
     NewRelic::Agent.manual_start
     NewRelic::Agent::Agent.instance.service = default_service(
       :connect => {'agent_run_id' => 23, 'config' => 'a lot'})
@@ -194,6 +194,50 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     NewRelic::Agent.shutdown
   end
 
+  def test_finish_setup_saves_transaction_name_rules
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
+                                            NewRelic::Agent::RulesEngine.new)
+    config = {
+      'transaction_name_rules' => [ { 'match_expression' => '88',
+                                      'replacement'      => '**' },
+                                    { 'match_expression' => 'xx',
+                                      'replacement'      => 'XX' } ]
+    }
+    finish_setup(config)
+
+    rules = NewRelic::Agent.instance.transaction_rules
+    assert_equal 2, rules.size
+    assert(rules.find{|r| r.match_expression == /88/ && r.replacement == '**' },
+           "rule not found among #{rules}")
+    assert(rules.find{|r| r.match_expression == /xx/ && r.replacement == 'XX' },
+           "rule not found among #{rules}")
+  ensure
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
+                                            NewRelic::Agent::RulesEngine.new)
+  end
+
+  def test_finish_setup_saves_metric_name_rules
+    NewRelic::Agent.instance.instance_variable_set(:@metric_rules,
+                                            NewRelic::Agent::RulesEngine.new)
+    config = {
+      'metric_name_rules' => [ { 'match_expression' => '77',
+                                 'replacement'      => '&&' },
+                               { 'match_expression' => 'yy',
+                                 'replacement'      => 'YY' }]
+    }
+    finish_setup(config)
+
+    rules = NewRelic::Agent.instance.metric_rules
+    assert_equal 2, rules.size
+    assert(rules.find{|r| r.match_expression == /77/ && r.replacement == '&&' },
+           "rule not found among #{rules}")
+    assert(rules.find{|r| r.match_expression == /yy/ && r.replacement == 'YY' },
+           "rule not found among #{rules}")
+  ensure
+    NewRelic::Agent.instance.instance_variable_set(:@metric_rules,
+                                            NewRelic::Agent::RulesEngine.new)
+  end
+
   def test_finish_setup
     config = {
       'agent_run_id' => 'fishsticks',

data/test/new_relic/agent/agent/start_worker_thread_test.rb

@@ -36,13 +36,10 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
 
     self.expects(:reset_stats)
     self.expects(:sleep).with(30)
-
-    @metric_ids = 'this is not an empty hash'
     @connected = true
 
     handle_force_restart(error)
 
-    assert_equal({}, @metric_ids)
     assert_equal(:pending, @connect_state)
   end
 

data/test/new_relic/agent/agent_test.rb

@@ -70,10 +70,6 @@ module NewRelic
         @agent.instance_eval { transmit_data }
       end
 
-      def test_serialize
-        assert_equal([{}, [], []], @agent.send(:serialize), "should return nil when shut down")
-      end
-
       def test_harvest_transaction_traces
         assert_equal([], @agent.send(:harvest_transaction_traces), 'should return transaction traces')
       end
@@ -121,23 +117,29 @@ module NewRelic
                      'should return timeslice data')
       end
 
-      def test_harvest_timelice_data_should_be_thread_safe
-        2000.times do |i|
-          @agent.stats_engine.stats_hash[i.to_s] = NewRelic::StatsBase.new
-        end
+      # This test asserts nothing about correctness of logging data from multiple
+      # threads, since the get_stats + record_data_point combo is not designed
+      # to be thread-safe, but it does ensure that writes to the stats hash
+      # via this path that happen concurrently with harvests will not cause
+      # 'hash modified during iteration' errors.
+      def test_harvest_timeslice_data_should_be_thread_safe
+        threads = []
+        nthreads = 10
+        nmetrics = 100
 
-        harvest = Thread.new("Harvesting Test run timeslices") do
-          @agent.send(:harvest_timeslice_data)
-        end
-
-        app = Thread.new("Harvesting Test Modify stats_hash") do
-          200.times do |i|
-            @agent.stats_engine.stats_hash["a#{i}"] = NewRelic::StatsBase.new
+        assert_nothing_raised do
+          nthreads.times do |tid|
+            t = Thread.new do
+              nmetrics.times do |mid|
+                @agent.stats_engine.get_stats("m#{mid}").record_data_point(1)
+              end
+            end
+            t.abort_on_exception = true
+            threads << t
           end
-        end
 
-        assert_nothing_raised do
-          [app, harvest].each{|t| t.join}
+          100.times { @agent.send(:harvest_timeslice_data) }
+          threads.each { |t| t.join }
         end
       end
 
@@ -228,28 +230,6 @@ module NewRelic
         assert_equal 0, NewRelic::Agent.get_stats("Errors/all").call_count
       end
 
-      def test_fill_metric_id_cache_from_collect_response
-        response = [[{"scope"=>"Controller/blogs/index", "name"=>"Database/SQL/other"}, 1328],
-                    [{"scope"=>"", "name"=>"WebFrontend/QueueTime"}, 10],
-                    [{"scope"=>"", "name"=>"ActiveRecord/Blog/find"}, 1017]]
-
-        @agent.send(:fill_metric_id_cache, response)
-        assert_equal 1328, @agent.metric_ids[MetricSpec.new('Database/SQL/other', 'Controller/blogs/index')]
-        assert_equal 10,   @agent.metric_ids[MetricSpec.new('WebFrontend/QueueTime')]
-        assert_equal 1017, @agent.metric_ids[MetricSpec.new('ActiveRecord/Blog/find')]
-      end
-
-      def test_fill_metric_id_cache_from_collect_response
-        response = [[{"scope"=>"Controller/blogs/index", "name"=>"Database/SQL/other"}, 1328],
-                    [{"scope"=>"", "name"=>"WebFrontend/QueueTime"}, 10],
-                    [{"scope"=>"", "name"=>"ActiveRecord/Blog/find"}, 1017]]
-
-        @agent.send(:fill_metric_id_cache, response)
-        assert_equal 1328, @agent.metric_ids[MetricSpec.new('Database/SQL/other', 'Controller/blogs/index')]
-        assert_equal 10,   @agent.metric_ids[MetricSpec.new('WebFrontend/QueueTime')]
-        assert_equal 1017, @agent.metric_ids[MetricSpec.new('ActiveRecord/Blog/find')]
-      end
-
       def test_connect_retries_on_timeout
         service = @agent.service
         def service.connect(opts={})