ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/test/new_relic/control_test.rb

@@ -4,7 +4,6 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   attr_reader :control
 
   def setup
-    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
     @control =  NewRelic::Control.instance
     raise 'oh geez, wrong class' unless NewRelic::Control.instance.is_a?(::NewRelic::Control::Frameworks::Test)
   end
@@ -17,12 +16,11 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     assert @control.cert_file_path
     assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @control.cert_file_path
   end
-  
+
   # This test does not actually use the ruby agent in any way - it's
   # testing that the CA file we ship actually validates our server's
   # certificate. It's used for customers who enable verify_certificate
   def test_cert_file
-    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 
@@ -34,12 +32,11 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     s.connect
     # should not raise an error
   end
-  
+
   # see above, but for staging, as well. This allows us to test new
   # certificates in a non-customer-facing place before setting them
   # live.
   def test_staging_cert_file
-    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 
@@ -52,26 +49,6 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     # should not raise an error
   end
 
-  def test_monitor_mode
-    assert ! @control.monitor_mode?
-    @control.settings.delete 'enabled'
-    @control.settings.delete 'monitor_mode'
-    assert !@control.monitor_mode?
-    @control['enabled'] = false
-    assert ! @control.monitor_mode?
-    @control['enabled'] = true
-    assert @control.monitor_mode?
-    @control['monitor_mode'] = nil
-    assert !@control.monitor_mode?
-    @control['monitor_mode'] = false
-    assert !@control.monitor_mode?
-    @control['monitor_mode'] = true
-    assert @control.monitor_mode?
-  ensure
-    @control['enabled'] = false
-    @control['monitor_mode'] = false
-  end
-
   def test_test_config
     if defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
       assert_equal :rails3, control.app
@@ -81,10 +58,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
       assert_equal :test, control.app
     end
     assert_equal :test, control.framework
-    assert_match /test/i, control.dispatcher_instance_id
-    assert("" == control.dispatcher.to_s, "Expected dispatcher to be empty, but was #{control.dispatcher.to_s}")
-    assert !control['enabled']
-    assert_equal false, control['monitor_mode']
+    assert_match /test/i, control.local_env.dispatcher_instance_id
+    assert("" == NewRelic::Agent.config[:dispatcher].to_s,
+           "Expected dispatcher to be empty, but was #{NewRelic::Agent.config[:dispatcher].to_s}")
+    assert_equal false, NewRelic::Agent.config[:monitor_mode]
     control.local_env
   end
 
@@ -96,19 +73,58 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_info
+    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
     props = NewRelic::Control.instance.local_env.snapshot
     if defined?(Rails)
       assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last, props.inspect
     end
   end
 
-  def test_resolve_ip
+  def test_resolve_ip_for_localhost
     assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+  end
+
+  def test_resolve_ip_for_non_existent_domain
+    Resolv.stubs(:getaddress).raises(Resolv::ResolvError)
+    IPSocket.stubs(:getaddress).raises(SocketError)
     assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
-    # This will fail if you don't have a valid, accessible, DNS server
+  end
+
+  def test_resolves_valid_ip
+    Resolv.stubs(:getaddress).with('collector.newrelic.com').returns('204.93.223.153')
     assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
   end
 
+  def test_do_not_resolve_if_we_need_to_verify_a_cert
+    assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    with_config(:ssl => true, :verify_certificate => true) do
+      assert_equal 'localhost', control.send(:convert_to_ip_address, 'localhost')
+    end
+  end
+
+  def test_api_server_uses_configured_values
+    control.instance_variable_set(:@api_server, nil)
+    with_config(:api_host => 'somewhere', :api_port => 8080) do
+      assert_equal 'somewhere', control.api_server.name
+      assert_equal 8080, control.api_server.port
+    end
+  end
+
+  def test_proxy_server_uses_configured_values
+    control.instance_variable_set(:@proxy_server, nil)
+    with_config(:proxy_host => 'proxytown', :proxy_port => 81) do
+      assert_equal 'proxytown', control.proxy_server.name
+      assert_equal 81, control.proxy_server.port
+    end
+  end
+
+  def test_server_from_host_uses_configured_values
+    with_config(:host => 'donkeytown', :port => 8080) do
+      assert_equal 'donkeytown', control.server_from_host.name
+      assert_equal 8080, control.server_from_host.port
+    end
+  end
+
   class FakeResolv
     def self.getaddress(host)
       raise 'deliberately broken'
@@ -131,126 +147,72 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     assert_equal old_ipsocket, IPSocket
   end
 
-  def test_config_yaml_erb
-    assert_equal 'heyheyhey', control['erb_value']
-    assert_equal '', control['message']
-    assert_equal '', control['license_key']
-  end
-
-  def test_appnames
-    assert_equal %w[a b c], NewRelic::Control.instance.app_names
-  end
-
-  def test_config_booleans
-    assert_equal control['tval'], true
-    assert_equal control['fval'], false
-    assert_nil control['not_in_yaml_val']
-    assert_equal control['yval'], true
-    assert_equal control['sval'], 'sure'
-  end
-
-  def test_config_apdex
-    assert_equal 1.1, control.apdex_t
-  end
-
-#  def test_transaction_threshold
-#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
-#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-#  end
-
   def test_log_file_name
     NewRelic::Control.instance.setup_log
     assert_match /newrelic_agent.log$/, control.instance_variable_get('@log_file')
   end
 
-#  def test_transaction_threshold__apdex
-#    forced_start
-#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
-#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-#  end
-
-  def test_transaction_threshold__default
-    forced_start :transaction_tracer => { :transaction_threshold => nil}
-    assert_nil control['transaction_tracer']['transaction_threshold']
-    assert_equal 2.0, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-  end
-
   def test_transaction_threshold__override
-    forced_start :transaction_tracer => { :transaction_threshold => 1}
-    assert_equal 1, control['transaction_tracer']['transaction_threshold']
-    assert_equal 1, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+    with_config(:transaction_tracer => { :transaction_threshold => 1}) do
+      assert_equal 1, NewRelic::Agent.config[:'transaction_tracer.transaction_threshold']
+    end
   end
 
   def test_transaction_tracer_disabled
-    forced_start(:transaction_tracer => { :enabled => false },
-                 :developer_mode => false, :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_transaction_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
-           'transaction tracer enabled when config calls for disabled')
-    
-    @control['developer_mode'] = true
-    @control['monitor_mode'] = false
+    with_config(:'transaction_tracer.enabled' => false,
+                :developer_mode => false, :monitor_mode => true) do
+      assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
+             'transaction tracer enabled when config calls for disabled')
+    end
   end
-  
+
   def test_sql_tracer_disabled
-    forced_start(:slow_sql => { :enabled => false }, :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql tracer enabled when config calls for disabled')
-    
-    @control['monitor_mode'] = false
+    with_config(:'slow_sql.enabled' => false, :monitor_mode => true) do
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql tracer enabled when config calls for disabled')
+    end
   end
-  
+
   def test_sql_tracer_disabled_with_record_sql_false
-    forced_start(:slow_sql => { :enabled => true, :record_sql => 'off' })
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql tracer enabled when config calls for disabled')
+    with_config(:slow_sql => { :enabled => true, :record_sql => 'off' }) do
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql tracer enabled when config calls for disabled')
+    end
   end
 
   def test_sql_tracer_disabled_when_tt_disabled
-    forced_start(:transaction_tracer => { :enabled => false },
-                 :slow_sql => { :enabled => true },
-                 :developer_mode => false, :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql enabled when transaction tracer disabled')
-    
-    @control['developer_mode'] = true
-    @control['monitor_mode'] = false    
+    with_config(:'transaction_tracer.enabled' => false,
+                :'slow_sql.enabled' => true,
+                :developer_mode => false, :monitor_mode => true) do
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql enabled when transaction tracer disabled')
+    end
   end
 
   def test_sql_tracer_disabled_when_tt_disabled_by_server
-    forced_start(:slow_sql => { :enabled => true },
-                 :transaction_tracer => { :enabled => true },
-                 :monitor_mode => true)
-    NewRelic::Agent::Agent.instance.check_sql_sampler_status
-    NewRelic::Agent::Agent.instance.finish_setup('collect_traces' => false)    
-    
-    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
-           'sql enabled when tracing disabled by server')
-    
-    @control['monitor_mode'] = false        
+    with_config({:'slow_sql.enabled' => true,
+                  :'transaction_tracer.enabled' => true,
+                  :monitor_mode => true}, 2) do
+      NewRelic::Agent.instance.finish_setup('collect_traces' => false)
+
+      assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+             'sql enabled when tracing disabled by server')
+    end
   end
 
-  def test_merging_options
-    NewRelic::Control.send :public, :merge_options
-    @control.merge_options :api_port => 66, :transaction_tracer => { :explain_threshold => 2.0 }
-    assert_equal 66, NewRelic::Control.instance['api_port']
-    assert_equal 2.0, NewRelic::Control.instance['transaction_tracer']['explain_threshold']
-    assert_equal 'raw', NewRelic::Control.instance['transaction_tracer']['record_sql']
+  def test_init_plugin_loads_samplers_enabled
+    NewRelic::Agent.shutdown
+    with_config(:disable_samplers => false, :agent_enabled => true) do
+      NewRelic::Control.instance.init_plugin
+      assert NewRelic::Agent.instance.stats_engine.send(:harvest_samplers).any?
+    end
   end
-    
-  private
 
-  def forced_start(overrides={})
-    NewRelic::Agent.manual_start overrides
-    # This is to force the agent to start again.
-    NewRelic::Agent.instance.stubs(:started?).returns(nil)
-    NewRelic::Agent.instance.start
+  def test_init_plugin_loads_samplers_disabled
+    NewRelic::Agent.shutdown
+    with_config(:disable_samplers => true, :agent_enabled => true) do
+      NewRelic::Control.instance.init_plugin
+      assert_equal [], NewRelic::Agent.instance.stats_engine.send(:harvest_samplers)
+    end
   end
 end

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' => [[{'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
@@ -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
+