wd_newrelic_rpm 3.5.5 → 3.5.6

data/test/new_relic/command/deployments_test.rb

@@ -79,6 +79,6 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
     @mock_response = mock()
     @mock_response.expects(:is_a?).with(Net::HTTPSuccess).returns(true)
     mock_connection.expects(:request).returns(@mock_response)
-    NewRelic::Control.instance.stubs(:http_connection).returns(mock_connection)
+    NewRelic::Agent::NewRelicService.any_instance.stubs(:http_connection).returns(mock_connection)
   end
 end

data/test/new_relic/control_test.rb

@@ -12,42 +12,6 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     NewRelic::Agent.shutdown
   end
 
-  def test_cert_file_path
-    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
-    require 'socket'
-    require 'openssl'
-
-    s   = TCPSocket.new 'collector.newrelic.com', 443
-    ctx = OpenSSL::SSL::SSLContext.new
-    ctx.ca_file = @control.cert_file_path
-    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    s   = OpenSSL::SSL::SSLSocket.new s, ctx
-    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
-    require 'socket'
-    require 'openssl'
-
-    s   = TCPSocket.new 'staging-collector.newrelic.com', 443
-    ctx = OpenSSL::SSL::SSLContext.new
-    ctx.ca_file = @control.cert_file_path
-    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-    s   = OpenSSL::SSL::SSLSocket.new s, ctx
-    s.connect
-    # should not raise an error
-  end
 
   def test_test_config
     if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
@@ -67,6 +31,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     control.local_env
   end
 
+  def test_settings_accessor
+    assert_not_nil control.settings
+  end
+
   def test_root
     assert File.directory?(NewRelic::Control.newrelic_root), NewRelic::Control.newrelic_root
     if defined?(Rails)
@@ -83,22 +51,30 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_resolve_ip_for_localhost
-    assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    with_config(:ssl => false, :verify_certificate => false) do
+      assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    end
   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')
+    with_config(:ssl => false, :verify_certificate => false) do
+      Resolv.stubs(:getaddress).raises(Resolv::ResolvError)
+      IPSocket.stubs(:getaddress).raises(SocketError)
+      assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
+    end
   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')
+    with_config(:ssl => false, :verify_certificate => false) do
+      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
   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 => false, :verify_certificate => false) do
+      assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    end
     with_config(:ssl => true, :verify_certificate => true) do
       assert_equal 'localhost', control.send(:convert_to_ip_address, 'localhost')
     end
@@ -140,7 +116,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     old_ipsocket = IPSocket
     Object.instance_eval { remove_const :Resolv}
     Object.instance_eval {remove_const:'IPSocket' }
-    assert_equal(nil, control.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+
+    with_config(:ssl => false, :verify_certificate => false) do
+      assert_equal(nil, control.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+    end
 
     Object.instance_eval {const_set('Resolv', old_resolv); const_set('IPSocket', old_ipsocket)}
     # these are here to make sure that the constant tomfoolery above

data/test/new_relic/fake_collector.rb

@@ -71,20 +71,48 @@ module NewRelic
       uri.query && uri.query.include?('marshal_format=json')
     end
 
-    def run(port=30303)
+    # We generate a "unique" port for ourselves based off our pid
+    # If this logic changes, look for multiverse newrelic.yml files to update
+    # with it duplicated (since we can't easily pull this ruby into a yml)
+    def self.determine_port
+      30_000 + ($$ % 10_000)
+    end
+
+    def determine_port
+      FakeCollector.determine_port
+    end
+
+    @seen_port_failure = false
+
+    def run(port=nil)
+      port ||= determine_port
       return if @thread && @thread.alive?
       serve_on_port(port) do
         @thread = Thread.new do
+          begin
           ::Rack::Handler::WEBrick.run(self,
                                        :Port => port,
-                                       :Logger => WEBrick::Log.new("/dev/null"),
-                                       :AccessLog => [nil, nil])
+                                       :Logger => ::WEBrick::Log.new("/dev/null"),
+                                       :AccessLog => [ ['/dev/null', ::WEBrick::AccessLog::COMMON_LOG_FORMAT] ]
+                                      )
+          rescue Errno::EADDRINUSE => ex
+            msg = "Port #{port} for FakeCollector was in use"
+            if !@seen_port_failure
+              # This is slow, so only do it the first collision we detect
+              lsof = `lsof | grep #{port}`
+              msg = msg + "\n#{lsof}"
+              @seen_port_failure = true
+            end
+
+            raise Errno::EADDRINUSE.new(msg)
+          end
         end
         @thread.abort_on_exception = true
       end
     end
 
     def serve_on_port(port)
+      port ||= determine_port
       if is_port_available?('127.0.0.1', port)
         yield
         loop do
@@ -127,7 +155,7 @@ module NewRelic
 
   # might we need this?  I'll just leave it here for now
   class FakeCollectorProcess < FakeCollector
-    def run(port=30303)
+    def run(port)
       serve_on_port(port) do
         @pid = Process.fork do
           ::Rack::Handler::WEBrick.run(self, :Port => port)
@@ -262,9 +290,9 @@ if $0 == __FILE__
     end
 
     def invoke(method, post={}, code=200)
-      uri = URI.parse("http://127.0.0.1:30303/agent_listener/8/12345/#{method}")
+      uri = URI.parse("http://127.0.0.1:#{determine_port}/agent_listener/8/12345/#{method}")
       request = Net::HTTP::Post.new("#{uri.path}?#{uri.query}")
-      if uri.query && uri.query.include?('marsha_format=json')
+      if uri.query && uri.query.include?('marshal_format=json')
         request.body = JSON.dump(post)
       else
         request.body = Marshal.dump(post)

data/test/new_relic/local_environment_test.rb

@@ -53,7 +53,7 @@ class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
     assert_equal 0, s.size
     e.gather_environment_info
     s = e.snapshot
-    assert_match /1\.(8\.[67]|9\.\d)/, s.assoc('Ruby version').last, s.inspect
+    assert_match /1\.8\.[67]|1\.9\.|2\.0/, s.assoc('Ruby version').last, s.inspect
     assert_equal 'test', s.assoc('Framework').last, s.inspect
     # Make sure the processor count is determined on linux systems
     if File.exists? '/proc/cpuinfo'

data/test/new_relic/metric_data_test.rb

@@ -151,4 +151,33 @@ class NewRelic::MetricDataTest < Test::Unit::TestCase
     expected = [ 1234, [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
     assert_equal expected, md.to_collector_array
   end
+
+  # Rationals in metric data? -- https://support.newrelic.com/tickets/28053
+  def test_to_collector_array_with_rationals
+    stats = NewRelic::MethodTraceStats.new
+    stats.call_count = Rational(1, 1)
+    stats.total_call_time = Rational(2, 1)
+    stats.total_exclusive_time = Rational(3, 1)
+    stats.min_call_time = Rational(4, 1)
+    stats.max_call_time = Rational(5, 1)
+    stats.sum_of_squares = Rational(6, 1)
+
+    md = NewRelic::MetricData.new(nil, stats, 1234)
+    expected = [1234, [1, 2.0, 3.0, 4.0, 5.0, 6.0]]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_bad_values
+    stats = NewRelic::MethodTraceStats.new
+    stats.call_count = nil
+    stats.total_call_time = "junk"
+    stats.total_exclusive_time = Object.new
+    stats.min_call_time = []
+    stats.max_call_time = {}
+    stats.sum_of_squares = Exception.new("Boo")
+
+    md = NewRelic::MetricData.new(nil, stats, 1234)
+    expected = [1234, [0, 0, 0, 0, 0, 0]]
+    assert_equal expected, md.to_collector_array
+  end
 end

data/test/new_relic/noticed_error_test.rb

@@ -16,6 +16,14 @@ class NewRelic::Agent::NoticedErrorTest < Test::Unit::TestCase
     assert_equal expected, error.to_collector_array
   end
 
+  def test_to_collector_array_with_bad_values
+    error = NewRelic::NoticedError.new(@path, @params, nil, Rational(10, 1))
+    expected = [
+      10_000.0, @path, "<no message>", "Error", @params
+    ]
+    assert_equal expected, error.to_collector_array
+  end
+
   def test_handles_non_string_exception_messages
     e = Exception.new({ :non => :string })
     error = NewRelic::NoticedError.new(@path, @params, e, @time)

data/test/new_relic/rack/agent_hooks_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/rack/agent_hooks'
+
+class AgentHooksTest < Test::Unit::TestCase
+
+  def setup
+    @app = stub_everything
+    @hooks = NewRelic::Rack::AgentHooks.new(@app)
+    @env = {:env => "env"}
+
+    NewRelic::Agent.instance.events.stubs(:notify)
+  end
+
+  def test_before_call
+    NewRelic::Agent.instance.events.expects(:notify).with(:before_call, @env)
+
+    @hooks.call(@env)
+  end
+
+  def test_after_call
+    result = stub
+    @app.stubs(:call).returns(result)
+
+    NewRelic::Agent.instance.events.expects(:notify).with(:after_call, @env, result)
+
+    @hooks.call(@env)
+  end
+
+end
+

data/test/new_relic/rack/error_collector_test.rb

@@ -66,6 +66,22 @@ module NewRelic::Rack
       assert(NewRelic::Agent.instance.error_collector.errors.empty?,
              'noticed an error that should have been ignored')
     end
+
+    def test_handles_parameter_parsing_exceptions
+      bad_request = stub(:env => {}, :path => '/', :referer => '')
+      bad_request.stubs(:params).raises(TypeError, "can't convert nil into Hash")
+      Rack::Request.stubs(:new).returns(bad_request)
+
+      assert_raise RuntimeError do
+        get '/'
+      end
+
+      assert_equal('unhandled error',
+                   NewRelic::Agent.instance.error_collector.errors[0].message)
+      assert_match(/failed to capture request parameters/i,
+                   NewRelic::Agent.instance.error_collector.errors[0].params[:request_params]['error'])
+    end
+
   end
 end
 

data/test/new_relic/transaction_sample/segment_test.rb

@@ -51,6 +51,13 @@ class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
     assert_equal(expected_array, parent.to_array)
   end
 
+  def test_to_array_with_bad_values
+    segment = NewRelic::TransactionSample::Segment.new(nil, nil, nil)
+    segment.end_trace(Rational(10, 1))
+    expected = [0, 10_000.0, "<unknown>", {}, []]
+    assert_equal(expected, segment.to_array)
+  end
+
   if RUBY_VERSION >= '1.9.2'
     def test_to_json
       parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent', 1)

data/test/new_relic/transaction_sample_test.rb

@@ -12,6 +12,12 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
 
     NewRelic::Agent::Database.stubs(:get_connection).returns @connection_stub
     @t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+
+    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+      @marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    else
+      @marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    end
   end
 
   def teardown
@@ -189,6 +195,13 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
     assert_equal expected_array, @t.to_array
   end
 
+
+  def test_to_array_with_bad_values
+    transaction = NewRelic::TransactionSample.new(nil)
+    expected = [0.0, {}, nil, [0, 0, "ROOT", {}, []]]
+    assert_equal expected, transaction.to_array
+  end
+
   if RUBY_VERSION >= '1.9.2'
     def test_to_json
       expected_string = JSON.dump([@t.start_time.to_f,
@@ -200,20 +213,35 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_to_collector_array
-    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
-      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-      trace_tree = compress(@t.to_json)
-    else
-      marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
-      trace_tree = @t.to_array
-    end
     expected_array = [(@t.start_time.to_f * 1000).round,
                       (@t.duration * 1000).round,
                       @t.params[:path], @t.params[:uri],
                       trace_tree,
                       @t.guid, nil, !!@t.force_persist]
 
-    assert_equal expected_array, @t.to_collector_array(marshaller.default_encoder)
+    assert_equal expected_array, @t.to_collector_array(@marshaller.default_encoder)
+  end
+
+  def test_to_collector_array_with_bad_values
+    transaction = NewRelic::TransactionSample.new(nil)
+    transaction.root_segment.end_trace(Rational(10, 1))
+
+    expected = [
+      0, 10_000,
+      nil, nil,
+      trace_tree(transaction),
+      transaction.guid,
+      nil, false]
+
+    assert_equal expected, transaction.to_collector_array(@marshaller.default_encoder)
+  end
+
+  def trace_tree(transaction=@t)
+    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+      trace_tree = compress(transaction.to_json)
+    else
+      trace_tree = transaction.to_array
+    end
   end
 
   def compress(string)

data/test/new_relic/version_number_test.rb

@@ -82,40 +82,16 @@ class NewRelic::VersionNumberTest < Test::Unit::TestCase
     assert v0 < '1.2.0.1'
     assert v0 > '1.1.0.1'
   end
+
   def test_string
     assert_equal '1.2.0', NewRelic::VersionNumber.new('1.2.0').to_s
     assert_equal '1.2', NewRelic::VersionNumber.new('1.2').to_s
   end
 
-  def test_gemspec_version_parsing
-    gemspec_contents = File.read(File.join(File.dirname(__FILE__), '..', '..', 'newrelic_rpm.gemspec'))
-    gemspec_contents =~ /s\.version\s*=\s*"(.*)"/
-    real_version = $1
-    assert_equal real_version, NewRelic::VERSION::STRING
-  end
-
-  def test_gemspec_parse_no_build
-    version = NewRelic::VERSION.parse_build_from_gemspec(NewRelic.fixture_path('gemspec_no_build.rb'))
-    assert_nil version
-  end
-
-  def test_gemspec_parse_with_build
-    version = NewRelic::VERSION.parse_build_from_gemspec(NewRelic.fixture_path('gemspec_with_build.rb'))
-    assert_equal '123', version
-  end
-
-  def test_gemspec_parse_with_build_and_stage
-    version = NewRelic::VERSION.parse_build_from_gemspec(NewRelic.fixture_path('gemspec_with_build_and_stage.rb'))
-    assert_equal '123.dev', version
-  end
-
-  def test_gemspec_parse_no_rubygems
-    Kernel.stubs(:const_defined?).with(:Gem).returns(false)
-    version = NewRelic::VERSION.parse_build_from_gemspec(NewRelic.fixture_path('gemspec_with_build_and_stage.rb'))
-    assert_equal '123.dev', version
-  end
-
-  def test_gemspec_parse_nonexistent
-    assert_nil NewRelic::VERSION.parse_build_from_gemspec('/really/not/a/real/path')
+  def test_build_version_string
+    version_string = NewRelic::VERSION.build_version_string(1, 2, 3, '4.beta')
+    assert_equal('1.2.3.4.beta', version_string)
+    version_string = NewRelic::VERSION.build_version_string(1, 2, 3, nil)
+    assert_equal('1.2.3', version_string)
   end
 end

data/test/script/ci.sh

@@ -64,13 +64,10 @@ fi
 
 echo `which ruby`
 ruby -v
+gem --version
 
 rake -h > /dev/null || gem install rake
 
-echo "generating gemspec"
-rake gemspec
-
-
 # make sure that we're in the project root
 script_dirname=`dirname $0`
 cd "$script_dirname/../../"
@@ -87,13 +84,17 @@ rpm_test_app_cache=~/workspace/.rpm_test_app_cache
   echo "updating local cache of rpm_test_app in $rpm_test_app_cache"
   git clone --mirror git://github.com/newrelic/rpm_test_app.git $rpm_test_app_cache || true
   cd $rpm_test_app_cache
+  git fetch || true
 )
 
 git clone $rpm_test_app_cache rpm_test_app
 cd rpm_test_app
 
+git fetch || true
 git checkout -t origin/$BRANCH || git checkout $BRANCH
-
+if [ -x $HOME/.rbenv/plugins/rbenv-gemsets ]; then
+  echo "$RUBY-$BRANCH" > .rbenv-gemsets
+fi
 
 # Re-write database.yml to this here doc
 ( cat << "YAML" ) > config/database.yml