wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/new_relic/delayed_job_injection_test.rb

@@ -5,8 +5,13 @@ class NewRelic::DelayedJobInstrumentationTest < Test::Unit::TestCase
     Object.const_set('Delayed', Module.new) unless defined?(Delayed)
     ::Delayed.const_set('Worker', Class.new) unless defined?(::Delayed::Worker)
     
+    # on JRuby we need to make sure the worker isn't running, it might
+    # try to log
+    worker = NewRelic::Agent.agent.instance_variable_get(:@worker_loop)
+    worker.stop if worker
+    
     NewRelic::Agent.stubs(:logger).raises(NoMethodError,
-                                            'tempoarily not allowed')
+                                          'temporarily not allowed')
     NewRelic::Agent.stubs(:respond_to?).with(:logger).returns(false)
     
     assert DependencyDetection.detect!

data/test/new_relic/dispatcher_test.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+
+# Test logic around detecting or configuring dispatcher
+class DispatcherTest < Test::Unit::TestCase
+
+  def setup
+    NewRelic::Agent.shutdown
+    NewRelic::Agent.reset_config
+  end
+
+  def assert_dispatcher_reported_to_environment_report(dispatcher)
+    NewRelic::Control.instance.local_env.gather_environment_info
+    key, value = NewRelic::Control.instance.local_env.snapshot.detect do |(k, v)|
+      k == "Dispatcher"
+    end
+    assert_equal dispatcher.to_s, value
+  end
+
+  def test_detects_dispatcher_via_loaded_libraries
+    class << self
+      module ::PhusionPassenger
+      end
+    end
+    assert_equal :passenger, NewRelic::Agent.config[:dispatcher]
+    assert_dispatcher_reported_to_environment_report :passenger
+  ensure
+    Object.send(:remove_const, :PhusionPassenger)
+  end
+
+  def test_detects_dispatcher_via_ENV_NEW_RELIC_DISPATCHER
+    ENV['NEW_RELIC_DISPATCHER'] = "foobared"
+    NewRelic::Agent.reset_config
+    assert_equal :foobared, NewRelic::Agent.config[:dispatcher]
+    assert_dispatcher_reported_to_environment_report :foobared
+  ensure
+    ENV['NEW_RELIC_DISPATCHER'] = nil
+  end
+
+  def test_detects_dispatcher_via_ENV_NEWRELIC_DISPATCHER
+    ENV['NEWRELIC_DISPATCHER'] = "bazbang"
+    NewRelic::Agent.reset_config
+    assert_equal :bazbang, NewRelic::Agent.config[:dispatcher]
+    assert_dispatcher_reported_to_environment_report :bazbang
+  ensure
+    ENV['NEWRELIC_DISPATCHER'] = nil
+  end
+
+  def test_detects_dispatcher_based_on_arguments_to_manual_start
+    NewRelic::Agent.manual_start(:dispatcher   => :resque)
+    assert_equal :resque, NewRelic::Agent.config[:dispatcher]
+    assert_dispatcher_reported_to_environment_report :resque
+  end
+
+end

data/test/new_relic/fake_collector.rb

@@ -0,0 +1,283 @@
+require 'rubygems'
+require 'rack'
+require 'uri'
+require 'socket'
+require 'timeout'
+require 'ostruct'
+require File.join(File.dirname(__FILE__), 'fakes_sending_data')
+
+require 'json' if RUBY_VERSION >= '1.9'
+
+module NewRelic
+  class FakeCollector
+    attr_accessor :agent_data, :mock
+
+    include FakesSendingData
+
+    def initialize
+      @id_counter = 0
+      @base_expectations = {
+        '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' => [[{'name' => '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
+
+    def agent_run_id
+      @id_counter += 1
+    end
+
+    def call(env)
+      req = ::Rack::Request.new(env)
+      res = ::Rack::Response.new
+      uri = URI.parse(req.url)
+      if uri.path =~ /agent_listener\/\d+\/.+\/(\w+)/
+        method = $1
+        format = json_format?(uri) && RUBY_VERSION >= '1.9' ? :json : :pruby
+        if @mock.keys.include? method
+          res.status = @mock[method][0]
+          if format == :json
+            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 format == :json
+          body = JSON.load(req.body.read)
+        else
+          body = Marshal.load(req.body.read)
+        end
+        @agent_data << OpenStruct.new(:action       => method,
+                                      :body         => body,
+                                      :run_id       => run_id,
+                                      :format       => format)
+      end
+      res.finish
+    end
+
+    def json_format?(uri)
+      uri.query && uri.query.include?('marshal_format=json')
+    end
+
+    def run(port=30303)
+      return if @thread && @thread.alive?
+      serve_on_port(port) do
+        @thread = Thread.new do
+          ::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
+        end
+      end
+    end
+
+    def stop
+      return unless @thread.alive?
+      ::Rack::Handler::WEBrick.shutdown
+      @thread.join
+      reset
+    end
+
+    def reset
+      @mock = @base_expectations.dup
+      @id_counter = 0
+      @agent_data = []
+    end
+
+    def is_port_available?(ip, port)
+      begin
+        Timeout::timeout(1) do
+          begin
+            s = TCPSocket.new(ip, port)
+            s.close
+            return false
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return true
+          end
+        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
+      @collector.run
+    end
+
+    def teardown
+      @collector.stop
+    end
+
+    def test_get_redirect
+      @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
+
+    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
+      assert_equal({'Foo/Bar' => [1,2,3], 'Baz/Cux' => [4,5,6]}, post.body)
+      assert_equal 1, post.run_id.to_i
+    end
+
+    def test_sql_trace_data
+      response = invoke('sql_trace_data?run_id=2',
+                        ['trace', 'trace', 'trace'])
+
+      assert_nil response
+      post = @collector.agent_data[0]
+      assert_equal 'sql_trace_data', post.action
+      assert_equal ['trace', 'trace', 'trace'], post.body
+      assert_equal 2, post.run_id.to_i
+    end
+
+    def test_transaction_sample_data
+      response = invoke('transaction_sample_data?run_id=3',
+                        ['node', ['node', 'node'], 'node'])
+
+      assert_nil 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_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')
+
+      assert_nil response
+      assert_equal 'shutdown', @collector.agent_data[0].action
+    end
+
+    def test_multiple_invokations
+      pid = Process.fork do
+        invoke('get_redirect_host')
+        invoke('connect')
+        invoke('metric_data?run_id=1')
+        invoke('transaction_sample_data?run_id=1')
+        invoke('shutdown?run_id=1')
+      end
+      invoke('get_redirect_host')
+      invoke('connect')
+      invoke('metric_data?run_id=2')
+      invoke('transaction_sample_data?run_id=2')
+      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',
+                  'transaction_sample_data', 'shutdown']
+      assert_equal expected.sort, @collector.agent_data.map(&:action).sort
+    end
+
+    def test_reset
+      @collector.mock['get_redirect_host'] = [200, 'never!']
+      @collector.reset
+      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}")
+      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
+      if uri.query && uri.query.include?('marshal_format=json')
+        JSON.load(response.body)
+      else
+        Marshal.load(response.body)
+      end
+    end
+  end
+end
+

data/test/new_relic/fake_service.rb

@@ -0,0 +1,53 @@
+require 'ostruct'
+require File.join(File.dirname(__FILE__), 'fakes_sending_data')
+
+module NewRelic
+  class FakeService
+    attr_accessor :request_timeout, :agent_id, :agent_data, :collector, :mock
+
+    include FakesSendingData
+
+    def initialize
+      @agent_data = []
+      @supported_methods = [ :connect, :metric_data, :transaction_sample_data,
+                             :error_data, :sql_trace_data, :profile_data,
+                             :get_agent_commands, :shutdown ]
+      @collector = NewRelic::Control::Server.new(:name => 'fakehost', :port => 0)
+      @id_counter = 0
+      @base_expectations = {
+        'get_redirect_host'       => 'localhost',
+        'connect'                 => { 'agent_run_id' => agent_run_id },
+        'get_agent_commands'      => [],
+        'metric_data'             => [[{ 'name' => 'Some/Metric/Spec' }, 1]],
+        'sql_trace_data'          => nil,
+        'transaction_sample_data' => nil,
+        'error_data'              => nil,
+        'shutdown'                => nil,
+      }
+      reset
+    end
+
+    def agent_run_id
+      @id_counter += 1
+    end
+
+    def reset
+      @mock = @base_expectations.dup
+      @id_counter = 0
+      @agent_data = []
+    end
+
+    def stub_service(method, value)
+      @mock[method.to_s] = value
+    end
+    
+    def method_missing(method, *args)
+      if @supported_methods.include?(method)
+        @agent_data << OpenStruct.new(:action => method, :params => args)
+        @mock[method.to_s]
+      else
+        super
+      end
+    end  
+  end
+end

data/test/new_relic/fakes_sending_data.rb

@@ -0,0 +1,30 @@
+module NewRelic
+  module FakesSendingData
+    def calls_for(method)
+      @agent_data. \
+        select { |d| d.action == method }. \
+        map { |d| d.body }
+    end
+
+    # Unpeel the inner layers of encoding applied by the JSON marshaller.
+    # I'm sorry.
+    def unpack_inner_blobs(req)
+      body = req.body
+      if req.format == :json
+        case req.action
+        when 'profile_data' then
+          body[0][4] = unpack(body[0][4])
+        when 'sql_trace_data' then
+          body[0][0][9] = unpack(body[0][0][9])
+        when 'transaction_sample_data' then
+          body[4] = unpack(body[4])
+        end
+      end
+      body
+    end
+
+    def unpack(blob)
+      JSON.load(Zlib::Inflate.inflate(Base64.decode64(blob)))
+    end
+  end
+end

data/test/new_relic/framework_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+
+# Test logic around detecting or configuring framework
+class FrameworkTest < Test::Unit::TestCase
+
+  def setup
+
+    # muck with this constant which forces the agent to load the
+    # NewRelic::Control::Frameworks::Test control so we can test the logic used
+    # to load the appropriate control object.
+    @old_newrelic_test_const = ::NewRelic::TEST
+    ::NewRelic.send(:remove_const, :TEST)
+
+    NewRelic::Agent.shutdown
+    NewRelic::Agent.reset_config
+
+    # don't bomb out trying to load frameworks that don't exist.
+    NewRelic::Control.stubs(:new_instance).returns(stub :init_plugin => nil)
+  end
+
+  def teardown
+    # Put things back how we found them
+    ::NewRelic.send(:const_set, :TEST,  @old_newrelic_test_const)
+  end
+
+  def test_detects_framework_via_loaded_libraries
+    class << self
+      module ::Merb
+        module Plugins
+        end
+      end
+    end
+    assert_equal :merb, NewRelic::Agent.config[:framework]
+  ensure
+    Object.send(:remove_const, :Merb)
+  end
+
+  def test_detects_framework_via_ENV_NEW_RELIC_FRAMEWORK
+    ENV['NEW_RELIC_FRAMEWORK'] = "foobared"
+    NewRelic::Agent.reset_config
+    assert_equal :foobared, NewRelic::Agent.config[:framework]
+  ensure
+    ENV['NEW_RELIC_FRAMEWORK'] = nil
+  end
+
+  def test_detects_framework_via_ENV_NEWRELIC_FRAMEWORK
+    ENV['NEWRELIC_FRAMEWORK'] = "bazbang"
+    NewRelic::Agent.reset_config
+    assert_equal :bazbang, NewRelic::Agent.config[:framework]
+  ensure
+    ENV['NEWRELIC_FRAMEWORK'] = nil
+  end
+end