wd_newrelic_rpm 3.5.5 → 3.5.6

data/test/multiverse/suites/{rails_3_queue_time → rails}/queue_time_test.rb

@@ -1,28 +1,9 @@
 # https://newrelic.atlassian.net/browse/RUBY-927
 
-ENV['NEW_RELIC_DISPATCHER'] = 'test'
-
-require 'action_controller/railtie'
-require 'rails/test_unit/railtie'
 require 'rails/test_help'
-require 'test/unit'
-
-# BEGIN RAILS APP
-
-class MyApp < Rails::Application
-  # We need a secret token for session, cookies, etc.
-  config.active_support.deprecation = :log
-  config.secret_token = "49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk"
-end
-MyApp.initialize!
-
-MyApp.routes.draw do
-  match '/:controller(/:action(/:id))'
-end
-
-class ApplicationController < ActionController::Base; end
+require './app'
 
-class TestController < ApplicationController
+class QueueController < ApplicationController
   include Rails.application.routes.url_helpers
 
   def queued
@@ -31,7 +12,6 @@ class TestController < ApplicationController
     end
   end
 end
-# END RAILS APP
 
 class QueueTimeTest < ActionDispatch::IntegrationTest
   def setup
@@ -64,7 +44,7 @@ class QueueTimeTest < ActionDispatch::IntegrationTest
   end
 
   def get_queued(header="HTTP_X_QUEUE_START")
-    get('/test/queued', nil, \
+    get('/queue/queued', nil, \
         header => "t=#{(Time.now.to_i * 1_000_000) - 1_000}")
   end
 

data/test/multiverse/suites/{rails_3_views → rails}/view_instrumentation_test.rb

@@ -1,47 +1,8 @@
-require "action_controller/railtie"
-require "rails/test_unit/railtie"
-require 'rails/test_help'
-require 'test/unit'
-
-# BEGIN RAILS APP
+require './app'
 
 ActionController::Base.view_paths = ['app/views']
 
-class MyApp < Rails::Application
-  # We need a secret token for session, cookies, etc.
-  config.active_support.deprecation = :log
-  config.secret_token = "49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk"
-  config.after_initialize do
-    NewRelic::Agent.manual_start
-  end
-end
-MyApp.initialize!
-
-MyApp.routes.draw do
-  match '/:controller(/:action(/:id))'
-end
-
-class ApplicationController < ActionController::Base; end
-
-# a basic active model compliant model we can render
-class Foo
-  extend ActiveModel::Naming
-  def to_model
-    self
-  end
-
-  def valid?()      true end
-  def new_record?() true end
-  def destroyed?()  true end
-
-  def errors
-    obj = Object.new
-    def obj.[](key)         [] end
-    def obj.full_messages() [] end
-    obj
-  end
-end
-class TestController < ApplicationController
+class ViewsController < ApplicationController
   include Rails.application.routes.url_helpers
   def template_render_with_3_partial_renders
     render 'index'
@@ -68,7 +29,9 @@ class TestController < ApplicationController
   end
 
   def file_render
-    render :file => File.expand_path(__FILE__), :content_type => 'text/plain', :layout => false
+    # We need any old file that's around, preferrably with ERB embedding
+    file = File.expand_path(File.join(File.dirname(__FILE__), "Envfile"))
+    render :file => file, :content_type => 'text/plain', :layout => false
   end
 
   def nothing_render
@@ -108,23 +71,20 @@ class TestController < ApplicationController
   end
 end
 
-# END RAILS APP
-
-
-class TestControllerTest < ActionController::TestCase
-  tests TestController
+class ViewControllerTest < ActionController::TestCase
+  tests ViewsController
   def setup
-    @controller = TestController.new
+    @controller = ViewsController.new
   end
 end
 
 # SANITY TESTS - Make sure nothing raises errors,
 # unless it's supposed to
-class SanityTest < TestControllerTest
+class SanityTest < ViewControllerTest
 
   # assert we can call any of these renders with no errors
   # (except the one that does raise an error)
-  (TestController.action_methods - ["raise_render"]).each do |method|
+  (ViewsController.action_methods - ["raise_render"]).each do |method|
     test "should not raise errors on GET to #{method.inspect}" do
       get method.dup
     end
@@ -142,25 +102,25 @@ class SanityTest < TestControllerTest
 end
 
 # A controller action that renders 1 template and the same partial 3 times
-class NormalishRenderTest < TestControllerTest
+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
     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/test/_a_partial.html.erb/Partial'" do
+  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
 
     partial_segments = sample.root_segment.called_segments.first.called_segments.first.called_segments
     assert_equal 3, partial_segments.size, "sanity check"
 
-    assert_equal ['View/test/_a_partial.html.erb/Partial'], partial_segments.map(&:metric_name).uniq
+    assert_equal ['View/views/_a_partial.html.erb/Partial'], partial_segments.map(&:metric_name).uniq
   end
 end
 
-class TextRenderTest < TestControllerTest
+class TextRenderTest < ViewControllerTest
   # it doesn't seem worth it to get consistent behavior here.
   if Rails::VERSION::MINOR.to_i == 0
     test "should not instrument rendering of text" do
@@ -178,7 +138,7 @@ class TextRenderTest < TestControllerTest
   end
 end
 
-class InlineTemplateRenderTest < TestControllerTest
+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
@@ -187,16 +147,16 @@ class InlineTemplateRenderTest < TestControllerTest
   end
 end
 
-class HamlRenderTest < TestControllerTest
+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
     text_segment = sample.root_segment.called_segments.first.called_segments.first
-    assert_equal 'View/test/haml_view.html.haml/Rendering', text_segment.metric_name
+    assert_equal 'View/views/haml_view.html.haml/Rendering', text_segment.metric_name
   end
 end
 
-class MissingTemplateTest < TestControllerTest
+class MissingTemplateTest < ViewControllerTest
   # Rails 3.0 has different behavior for rendering an empty array.  We're okay with this.
   if Rails::VERSION::MINOR.to_i == 0
     test "should create an proper metric when the template is unknown" do
@@ -215,7 +175,7 @@ class MissingTemplateTest < TestControllerTest
   end
 end
 
-class CollectionTemplateTest < TestControllerTest
+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
@@ -224,7 +184,7 @@ class CollectionTemplateTest < TestControllerTest
   end
 end
 
-class UninstrumentedRendersTest < TestControllerTest
+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
@@ -234,7 +194,7 @@ class UninstrumentedRendersTest < TestControllerTest
   end
 end
 
-class FileRenderTest < TestControllerTest
+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

data/test/multiverse/suites/resque/Envfile

@@ -1,21 +1,24 @@
-suite_condition("Resque not compatible with 1.8.6") do
-  RUBY_VERSION != '1.8.6'
+suite_condition("Resque tests not compatible with 1.8.6, JRuby") do
+  RUBY_VERSION != '1.8.6' && RUBY_PLATFORM != 'java'
 end
 
 gemfile <<-RB
   gem 'resque'
   gem 'json'
+  gem 'rake'
   if (RUBY_PLATFORM == 'java')
     gem "jruby-openssl"
   end
 RB
 
 before_suite do
-  system('echo "daemonize yes" | redis-server -')
+  ENV["NEWRELIC_MULTIVERSE_REDIS_PORT"] = (20_000 + ($$ % 10_000)).to_s
+  ENV["NEWRELIC_MULTIVERSE_FAKE_COLLECTOR_PORT"] = (30_000 + ($$ % 10_000)).to_s
+  system("echo 'port #{ENV["NEWRELIC_MULTIVERSE_REDIS_PORT"]}' | redis-server - > /dev/null &")
 end
 
 after_suite do
-  system('redis-cli shutdown')
+  system("redis-cli -p #{ENV["NEWRELIC_MULTIVERSE_REDIS_PORT"]} shutdown")
 end
 
 execute_mode 'spawn'

data/test/multiverse/suites/resque/Rakefile

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__), 'resque_setup')
+require 'resque/tasks'
+
+task "resque:setup" do
+  if ENV['BROKEN_AFTER_FORK']
+    Resque.before_fork = Proc.new { 'doot de doo' }
+  end
+end

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

@@ -11,7 +11,7 @@ development:
   app_name: test
   host: 127.0.0.1
   api_host: 127.0.0.1
-  port: 30303
+  port: <%= ENV['NEWRELIC_MULTIVERSE_FAKE_COLLECTOR_PORT'] %>
   transaction_tracer:
     record_sql: obfuscated
     enabled: true

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

@@ -5,69 +5,146 @@ require 'test/unit'
 require 'logger'
 require 'newrelic_rpm'
 require 'fake_collector'
-
-class JobForTesting
-  @queue = :resque_test
-
-  def self.perform(key, val, sleep_duration=0)
-    sleep sleep_duration
-    Redis.new.set(key, val)
-  end
-end
+require File.join(File.dirname(__FILE__), 'resque_setup')
 
 class ResqueTest < Test::Unit::TestCase
   JOB_COUNT = 5
+  COLLECTOR_PORT = ENV['NEWRELIC_MULTIVERSE_FAKE_COLLECTOR_PORT']
 
   def setup
-    @redis = Redis.new
-
     $collector ||= NewRelic::FakeCollector.new
     $collector.reset
-    $collector.run
+    $collector.run(COLLECTOR_PORT)
+    $redis.del('queue:resque_test')
+    $redis.set('index_key', 0)
+    @pidfile = "resque_test.#{$$}.pid"
+    JOB_COUNT.times do |i|
+      Resque.enqueue(JobForTesting, 'index_key', i + 1)
+    end
+  end
 
-    NewRelic::Agent.manual_start
-    DependencyDetection.detect!
+  def teardown
+    File.unlink(@pidfile) if File.file?(@pidfile)
+  end
 
-    JOB_COUNT.times {|i| Resque.enqueue(JobForTesting, 'index_key', i + 1) }
-    worker = Resque::Worker.new(:resque_test)
-    Thread.new do
-      worker.work
-    end.abort_on_exception = true
-    sleep 1 # give the worker some time to process
-    worker.shutdown
+  def start_worker(opts={})
+    if opts[:background]
+      start_worker_background(opts[:env_vars])
+    else
+      start_worker_child(opts[:env_vars])
+    end
+  end
 
-    NewRelic::Agent.shutdown
-    sleep 0.5 # give the agent some time to report after shutdown
+  def stop_worker(opts={})
+    opts[:background] ? stop_worker_background : stop_worker_child
   end
 
-  def teardown
-    @redis.set('index_key', 0)
-    Resque.redis.del('queue:resque_test')
-    $collector.reset
+  def start_worker_child(env_vars=nil)
+    worker_cmd = "NEWRELIC_DISPATCHER=resque #{env_vars} QUEUE=* bundle exec rake resque:work"
+    @worker_pid = Process.fork
+    Process.exec(worker_cmd) if @worker_pid.nil?
+  end
+
+  def stop_worker_child
+    Process.kill("QUIT", @worker_pid)
+    Process.waitpid(@worker_pid)
+  end
+
+  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"
+    system(worker_cmd)
   end
 
-  def test_resque_instrumentation_is_installed
-    assert DependencyDetection.installed?(:resque)
+  def stop_worker_background
+    daemon_pid = File.read(@pidfile).to_i
+
+    tries = 0
+    while process_alive?(daemon_pid) && tries < 3
+      Process.kill('TERM', daemon_pid)
+      sleep 4 # default resque TERM timeout
+      tries += 1
+    end
+
+    if process_alive?(daemon_pid)
+      $stderr.puts "Oops. Daemon (pid #{daemon_pid}) is still running. Trying to halt it with SIGQUIT"
+      Process.kill('QUIT', daemon_pid)
+      sleep 1
+
+      # If it's still alive, someone will likely have to go kill the process manually. 
+      # Alternatively, we could kill -9 it, but I decided to err on the side of caution
+      if process_alive?(daemon_pid)
+        raise "Resque is zombified. You might have to clean up process #{daemon_pid} manually."
+      end
+    end
+  end
+
+  def process_alive?(pid)
+    Process.kill(0, pid)
+    return true
+  rescue Errno::ESRCH
+    return false
+  end
+
+  def wait_for_jobs
+    time_for_jobs = 5
+    begin
+      Timeout.timeout(time_for_jobs) { sleep(0.1) until Resque.info[:pending].zero? }
+    rescue Timeout::Error => err
+      raise err.exception("waiting #{time_for_jobs}s for completion of #{JOB_COUNT} jobs")
+    end
+  end
+
+  def run_worker(opts={})
+    begin
+      start_worker(opts)
+      wait_for_jobs
+    ensure
+      stop_worker(opts)
+    end
+  end
+
+  METRIC_VALUES_POSITION = 3
+
+  def assert_metric_and_call_count(name, expected_call_count)
+    metric_data = $collector.calls_for('metric_data')
+    assert_equal(1, metric_data.size, "expected exactly one metric_data post from agent")
+
+    metric = metric_data.first[METRIC_VALUES_POSITION].find { |m| m[0]['name'] == name }
+    assert(metric, "could not find metric named #{name}")
+
+    call_count = metric[1][0]
+    assert_equal(expected_call_count, call_count)
   end
 
   def test_all_jobs_ran
-    assert_equal JOB_COUNT, @redis.get('index_key').to_i
+    run_worker
+    assert_equal(JOB_COUNT, $redis.get('index_key').to_i)
   end
 
-  def test_agent_makes_only_one_metric_post
-    assert_equal(1, $collector.agent_data.select{|x| x.action == 'metric_data'}.size,
-                 "wrong number of metric_data posts in #{$collector.agent_data.inspect}")
+  def test_agent_posts_correct_metric_data
+    run_worker
+    assert_metric_and_call_count('OtherTransaction/ResqueJob/all', JOB_COUNT)
   end
 
-  def test_agent_posts_correct_call_count
-    test_metric = 'OtherTransaction/ResqueJob/all'
-    metric_data = $collector.agent_data.find{|x| x.action == 'metric_data'}
+  def test_log_properly_when_fork_callbacks_are_broken
+    log_path = File.join(File.dirname(__FILE__), 'agent.log', 'newrelic_agent.log')
+    File.delete(log_path)
+
+    run_worker(:env_vars => 'BROKEN_AFTER_FORK=true')
+
+    assert File.read(log_path).include?('Unable to send data to parent process')
+  end
 
-    metric_names = metric_data.body[3].map{|m| m[0]['name']}
-    assert(metric_names.include?(test_metric),
-           "#{metric_names.inspect} should include '#{test_metric}'")
+  if RUBY_VERSION >= '1.9'
+    def test_all_jobs_ran_background
+      run_worker(:background => true)
+      assert_equal(JOB_COUNT, $redis.get('index_key').to_i)
+    end
 
-    call_count = metric_data.body[3].find{|m| m[0]['name'] == test_metric}[1][0]
-    assert_equal JOB_COUNT, call_count
+    def test_agent_posts_correct_metric_data_background
+      run_worker(:background => true)
+      assert_metric_and_call_count('OtherTransaction/ResqueJob/all', JOB_COUNT)
+    end
   end
 end