newrelic_rpm 3.5.2.17 → 3.5.3.24

data/test/new_relic/agent/thread_test.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/thread'
+
+class ThreadTest < Test::Unit::TestCase
+
+  def test_sets_label
+    t = NewRelic::Agent::Thread.new("labelled") {}
+    assert_equal "labelled", t[:newrelic_label]
+  end
+
+  def test_bucket_thread_as_agent_when_profiling
+    t = NewRelic::Agent::Thread.new("labelled") {}
+    assert_equal :agent, NewRelic::Agent::Thread.bucket_thread(t, true)
+  end
+
+  def test_bucket_thread_as_agent_when_not_profiling
+    t = NewRelic::Agent::Thread.new("labelled") {}
+    assert_equal :ignore, NewRelic::Agent::Thread.bucket_thread(t, false)
+  end
+
+  def test_bucket_thread_as_request
+    t = ::Thread.new {}
+    frame = NewRelic::Agent::Instrumentation::MetricFrame.new
+    frame.request = "has a request"
+    t[:newrelic_metric_frame] = frame
+
+    assert_equal :request, NewRelic::Agent::Thread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_bucket_thread_as_background
+    t = ::Thread.new {}
+    frame = NewRelic::Agent::Instrumentation::MetricFrame.new
+    t[:newrelic_metric_frame] = frame
+
+    assert_equal :background, NewRelic::Agent::Thread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_bucket_thread_as_other_if_nil_frame
+    t = ::Thread.new {}
+    t[:newrelic_metric_frame] = nil
+
+    assert_equal :other, NewRelic::Agent::Thread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_bucket_thread_as_other
+    t = ::Thread.new {}
+    assert_equal :other, NewRelic::Agent::Thread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_runs_block
+    called = false
+
+    t = NewRelic::Agent::Thread.new("labelled") { called = true }
+    t.join
+
+    assert called
+  end
+
+  TRACE = [
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/eventmachine-0.12.10/lib/eventmachine.rb:100:in `catch'",
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/newrelic_rpm-3.5.3.452.dev/lib/new_relic/agent/agent.rb:200:in `start_worker_thread'",
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/thin-1.5.0/lib/thin/backends/base.rb:300:in `block (3 levels) in run'",
+    ]
+
+  def test_scrubs_backtrace_when_not_profiling_agent_code
+    result = NewRelic::Agent::Thread.scrub_backtrace(stub(:backtrace => TRACE), false)
+    assert_equal [TRACE[0], TRACE[2]], result
+  end
+
+  def test_doesnt_scrub_backtrace_when_profiling_agent_code
+    result = NewRelic::Agent::Thread.scrub_backtrace(stub(:backtrace => TRACE), true)
+    assert_equal TRACE, result
+  end
+
+  DONT_CARE = true
+end

data/test/new_relic/agent/threaded_test.rb

@@ -0,0 +1,65 @@
+class ThreadedTest < Test::Unit::TestCase
+  def setup
+    @original_thread_class = NewRelic::Agent::Thread
+    swap_thread_class(FakeThread)
+  end
+
+  def teardown
+    swap_thread_class(@original_thread_class)
+    @original_thread_class = nil
+
+    FakeThread.list.clear
+  end
+
+  def default_test
+    # no-op to keep quiet....
+  end
+
+  private
+
+  def swap_thread_class(klass)
+    NewRelic::Agent.send(:remove_const, "Thread") if NewRelic::Agent.const_defined?("Thread")
+    NewRelic::Agent.const_set("Thread", klass)
+  end
+end
+
+class FakeThread
+  @@list = []
+
+  def initialize(locals={}, &block)
+    @locals = locals
+    yield if block_given?
+  end
+
+  def self.current
+    {}
+  end
+
+  def self.list
+    @@list
+  end
+
+  def self.bucket_thread(thread, _)
+    thread[:bucket] 
+  end
+
+  def self.scrub_backtrace(thread, _)
+    thread[:scrubbed_backtrace] || thread.backtrace
+  end
+
+  def key?(key)
+    @locals.key?(key)
+  end
+
+  def [](key)
+    @locals[key]
+  end
+
+  def backtrace
+    @locals[:backtrace] || []
+  end
+
+  def join
+  end
+end
+

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -730,27 +730,30 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   # sample traces, for example. It's unfortunate, but we can't
   # reliably turn off GC on all versions of ruby under test
   def test_harvest_slowest
-    run_sample_trace
-    run_sample_trace
-    run_sample_trace { sleep 0.1 }
-    run_sample_trace
-    run_sample_trace
+    run_sample_trace(0,0.1)
+    run_sample_trace(0,0.1)
+    # two second duration
+    run_sample_trace(0,2)
+    run_sample_trace(0,0.1)
+    run_sample_trace(0,0.1)
 
     with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+
       slowest = @sampler.harvest(nil)[0]
       first_duration = slowest.duration
-      assert((first_duration >= 0.1),
-             "expected sample duration >= 0.1, but was: #{slowest.duration.inspect}")
+      assert((first_duration.round >= 2),
+             "expected sample duration = 2, but was: #{slowest.duration.inspect}")
 
-      run_sample_trace { sleep 0.0001 }
+      # 1 second duration
+      run_sample_trace(0,1)
       not_as_slow = @sampler.harvest(slowest)[0]
       assert((not_as_slow == slowest), "Should re-harvest the same transaction since it should be slower than the new transaction - expected #{slowest.inspect} but got #{not_as_slow.inspect}")
 
-      run_sample_trace { sleep(first_duration + 0.1) }
+      run_sample_trace(0,10)
 
       new_slowest = @sampler.harvest(slowest)[0]
       assert((new_slowest != slowest), "Should not harvest the same trace since the new one should be slower")
-      assert((new_slowest.duration >= first_duration + 0.1), "Slowest duration must be >= #{first_duration + 0.1}, but was: #{new_slowest.duration.inspect}")
+      assert_equal(new_slowest.duration.round, 10, "Slowest duration must be = 10, but was: #{new_slowest.duration.inspect}")
     end
   end
 
@@ -935,8 +938,8 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   private
 
-  def run_sample_trace
-    @sampler.notice_first_scope_push Time.now.to_f
+  def run_sample_trace(start = Time.now.to_f, stop = nil)
+    @sampler.notice_first_scope_push start
     @sampler.notice_transaction '/path', nil, {}
     @sampler.notice_push_scope "a"
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'wheat'", nil, 0)
@@ -948,6 +951,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", nil, 0)
     @sampler.notice_pop_scope "ac"
     @sampler.notice_pop_scope "a"
-    @sampler.notice_scope_empty
+    @sampler.notice_scope_empty stop || Time.now.to_f
   end
 end

data/test/new_relic/agent/worker_loop_test.rb

@@ -19,6 +19,23 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     assert @x
   end
 
+  def test_with_duration
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 0.1)
+    count = 0
+    worker_loop.run(0.04) do
+      count += 1
+    end
+
+    assert_equal 2, count
+  end
+
+  def test_loop_limit
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 2)
+    iterations = 0
+    worker_loop.run(0) { iterations += 1 }
+    assert_equal 2, iterations
+  end
+
   def test_density
     # This shows how the tasks stay aligned with the period and don't drift.
     count = 0
@@ -33,6 +50,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     elapsed = Time.now - start
     assert_in_delta 0.09, elapsed, 0.03
   end
+
   def test_task_error__standard
     @logger.expects(:debug)
     @logger.expects(:error)
@@ -45,6 +63,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     end
     assert done
   end
+
   class BadBoy < StandardError; end
 
   def test_task_error__exception
@@ -55,6 +74,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
       raise BadBoy, "oops"
     end
   end
+
   def test_task_error__server
     @logger.expects(:error).never
     @logger.expects(:debug).once

data/test/new_relic/fake_collector.rb

@@ -8,17 +8,18 @@ require 'ostruct'
 module NewRelic
   class FakeCollector
     attr_accessor :agent_data, :mock
-    
+
     def initialize
       @id_counter = 0
       @base_expectations = {
-        'get_redirect_host'       => 'localhost',
-        'connect'                 => { 'agent_run_id' => agent_run_id },
-        'metric_data'             => { 'Some/Metric/Spec' => 1 },
-        'sql_trace_data'          => nil,
-        'transaction_sample_data' => nil,
-        'error_data'              => nil,
-        'shutdown'                => nil,
+        'get_redirect_host'       => [200, {'return_value' => 'localhost'}],
+        'connect'                 => [200, {'return_value' => {"agent_run_id" => agent_run_id}}],
+        'get_agent_commands'      => [200, {'return_value' => []}],
+        'metric_data'             => [200, {'return_value' => {'Some/Metric/Spec' => 1}}],
+        'sql_trace_data'          => [200, {'return_value' => nil}],
+        'transaction_sample_data' => [200, {'return_value' => nil}],
+        'error_data'              => [200, {'return_value' => nil}],
+        'shutdown'                => [200, {'return_value' => nil}]
       }
       reset
     end
@@ -26,7 +27,7 @@ module NewRelic
     def agent_run_id
       @id_counter += 1
     end
-    
+
     def call(env)
       req = ::Rack::Request.new(env)
       res = ::Rack::Response.new
@@ -34,25 +35,57 @@ module NewRelic
       if uri.path =~ /agent_listener\/\d+\/.+\/(\w+)/
         method = $1
         if @mock.keys.include? method
-          res.write Marshal.dump(@mock[method])
+          res.status = @mock[method][0]
+          if json_format?(uri)
+            res.write JSON.dump(@mock[method][1])
+          else
+            res.write Marshal.dump(@mock[method][1])
+          end
         else
           res.status = 500
           res.write "Method not found"
         end
         run_id = uri.query =~ /run_id=(\d+)/ ? $1 : nil
         req.body.rewind
+        body = if json_format?(uri) && RUBY_VERSION >= '1.9'
+          require 'json'
+          JSON.load(req.body.read)
+        else
+          Marshal.load(req.body.read)
+        end
         @agent_data << OpenStruct.new(:action => method,
-                                      :body   => Marshal.load(req.body.read),
+                                      :body   => body,
                                       :run_id => run_id)
       end
       res.finish
     end
 
+    def calls_for(method)
+      @agent_data. \
+        select { |d| d.action == method }. \
+        map { |d| d.body }
+    end
+
+    def json_format?(uri)
+      uri.query && uri.query.include?('marshal_format=json')
+    end
+
     def run(port=30303)
-      if is_port_available?('127.0.0.1', port)
+      return if @thread && @thread.alive?
+      serve_on_port(port) do
         @thread = Thread.new do
-          ::Rack::Handler::WEBrick.run(self, :Port => port)
+          ::Rack::Handler::WEBrick.run(self,
+                                       :Port => port,
+                                       :Logger => WEBrick::Log.new("/dev/null"),
+                                       :AccessLog => [nil, nil])
         end
+        @thread.abort_on_exception = true
+      end
+    end
+
+    def serve_on_port(port)
+      if is_port_available?('127.0.0.1', port)
+        yield
         loop do
           break if !is_port_available?('127.0.0.1', port)
           sleep 0.01
@@ -61,8 +94,10 @@ module NewRelic
     end
 
     def stop
+      return unless @thread.alive?
       ::Rack::Handler::WEBrick.shutdown
       @thread.join
+      reset
     end
 
     def reset
@@ -70,7 +105,7 @@ module NewRelic
       @id_counter = 0
       @agent_data = []
     end
-    
+
     def is_port_available?(ip, port)
       begin
         Timeout::timeout(1) do
@@ -84,16 +119,33 @@ module NewRelic
         end
       rescue Timeout::Error
       end
-      
+
       return true
     end
   end
+
+  # might we need this?  I'll just leave it here for now
+  class FakeCollectorProcess < FakeCollector
+    def run(port=30303)
+      serve_on_port(port) do
+        @pid = Process.fork do
+          ::Rack::Handler::WEBrick.run(self, :Port => port)
+        end
+      end
+    end
+
+    def stop
+      return unless @pid
+      Process.kill('QUIT', @pid)
+      Process.wait(@pid)
+    end
+  end
 end
 
 if $0 == __FILE__
   require 'test/unit'
   require 'net/http'
-  
+
   class FakeCollectorTest < Test::Unit::TestCase
     def setup
       @collector = NewRelic::FakeCollector.new
@@ -103,18 +155,18 @@ if $0 == __FILE__
     def teardown
       @collector.stop
     end
-    
+
     def test_get_redirect
-      @collector.mock['get_redirect_host'] = 'test.example.com'
+      @collector.mock['get_redirect_host'] = [200, 'test.example.com']
       response = invoke('get_redirect_host')
-      
+
       assert_equal 'test.example.com', response
       assert_equal 'get_redirect_host', @collector.agent_data[0].action
     end
-    
+
     def test_connect
       response = invoke('connect')
-      
+
       assert_equal 1, response['agent_run_id']
       assert_equal 'connect', @collector.agent_data[0].action
     end
@@ -122,7 +174,7 @@ if $0 == __FILE__
     def test_metric_data
       response = invoke('metric_data?run_id=1',
                         {'Foo/Bar' => [1,2,3], 'Baz/Cux' => [4,5,6]})
-      
+
       assert_equal 1, response['Some/Metric/Spec']
       post = @collector.agent_data[0]
       assert_equal 'metric_data', post.action
@@ -151,16 +203,27 @@ if $0 == __FILE__
       assert_equal ['node', ['node', 'node'], 'node'], post.body
       assert_equal 3, post.run_id.to_i
     end
-    
+
+    def test_transaction_sample_data_json
+      response = invoke('transaction_sample_data?run_id=3&marshal_format=json',
+                        '["node",["node","node"],"node"]')
+
+      assert_equal '', response
+      post = @collector.agent_data[0]
+      assert_equal 'transaction_sample_data', post.action
+      assert_equal '["node",["node","node"],"node"]', post.body
+      assert_equal 3, post.run_id.to_i
+    end
+
     def test_error_data
       response = invoke('error_data?run_id=4', ['error'])
-      
+
       assert_nil response
       post = @collector.agent_data[0]
       assert_equal 'error_data', post.action
       assert_equal ['error'], post.body
     end
-    
+
     def test_shutdown
       response = invoke('shutdown?run_id=1')
 
@@ -183,7 +246,7 @@ if $0 == __FILE__
       invoke('shutdown?run_id=2')
 
       Process.wait(pid)
-      
+
       expected = ['get_redirect_host', 'connect', 'metric_data',
                   'transaction_sample_data', 'shutdown',
                   'get_redirect_host', 'connect', 'metric_data',
@@ -192,19 +255,28 @@ if $0 == __FILE__
     end
 
     def test_reset
-      @collector.mock['get_redirect_host'] = 'never!'
+      @collector.mock['get_redirect_host'] = [200, 'never!']
       @collector.reset
-      assert_equal 'localhost', @collector.mock['get_redirect_host']
+      assert_equal [200, 'localhost'], @collector.mock['get_redirect_host']
     end
-   
+
     def invoke(method, post={}, code=200)
       uri = URI.parse("http://127.0.0.1:30303/agent_listener/8/12345/#{method}")
       request = Net::HTTP::Post.new("#{uri.path}?#{uri.query}")
-      request.body = Marshal.dump(post)
+      if uri.query && uri.query.include?('marsha_format=json')
+        request.body = JSON.dump(post)
+      else
+        request.body = Marshal.dump(post)
+      end
       response = Net::HTTP.start(uri.host, uri.port) do |http|
         http.request(request)
       end
-      Marshal.load(response.body)
+      if uri.query && uri.query.include?('marshal_format=json')
+        JSON.load(response.body)
+      else
+        Marshal.load(response.body)
+      end
     end
   end
 end
+