newrelic_rpm 3.17.1.326 → 3.17.2.327

data/test/fixtures/cross_agent_tests/datastores/datastore_instances.json

@@ -31,22 +31,6 @@
     "port": 5252,
     "expected_instance_metric": "Datastore/instance/Postgres/datanerd-01/5252"
   },
-  {
-    "name": "instance metric uses system hostname when db reports default host IPv4",
-    "system_hostname": "datanerd-01",
-    "db_hostname": "0.0.0.0",
-    "product": "MySQL",
-    "port": 3600,
-    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/3600"
-  },
-  {
-    "name": "instance metric uses system hostname when db reports default host IPv6",
-    "system_hostname": "datanerd-01",
-    "db_hostname": "0:0:0:0:0:0:0:0",
-    "product": "MySQL",
-    "port": 5757,
-    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/5757"
-  },
   {
     "name": "instance metric uses system hostname when db reports default host IPv6 shorthand",
     "system_hostname": "datanerd-01",
@@ -63,13 +47,6 @@
     "port": 8420,
     "expected_instance_metric": "Datastore/instance/MySQL/accounts-db/8420"
   },
-  {
-    "name": "detects default UDS case",
-    "system_hostname": "datanerd-01",
-    "db_hostname": "localhost",
-    "product": "MySQL",
-    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/default"
-  },
   {
     "name": "instance metric uses unix socket path if provided",
     "system_hostname": "datanerd-01",
@@ -78,30 +55,6 @@
     "unix_socket": "/var/mysql/mysql.sock",
     "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01//var/mysql/mysql.sock"
   },
-  {
-    "name": "instance metric reports unknown if host empty",
-    "system_hostname": "datanerd-01",
-    "db_hostname": "",
-    "product": "MySQL",
-    "port": 3600,
-    "expected_instance_metric": "Datastore/instance/MySQL/unknown/3600"
-  },
-  {
-    "name": "instance metric reports unknown if port empty",
-    "system_hostname": "datanerd-01",
-    "db_hostname": "localhost",
-    "product": "MySQL",
-    "port": "",
-    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/unknown"
-  },
-  {
-    "name": "instance metric reports unknown if unix_socket empty",
-    "system_hostname": "datanerd-01",
-    "db_hostname": "localhost",
-    "product": "MySQL",
-    "unix_socket": "",
-    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/unknown"
-  },
   {
     "name": "instance metric with ip v6 host",
     "system_hostname": "datanerd-01",

data/test/multiverse/lib/multiverse/runner.rb

@@ -85,12 +85,13 @@ module Multiverse
       "agent"         => ["agent_only", "bare", "config_file_loading",
                           "deferred_instrumentation", "high_security", "no_json"],
       "api"           => ["grape"],
-      "background"    => ["delayed_job", "rake", "resque", "sidekiq"],
+      "background"    => ["delayed_job", "resque", "sidekiq"],
       "database"      => ["datamapper", "mongo", "redis", "sequel"],
       "httpclients"   => ["curb", "excon", "httpclient", "typhoeus", "net_http", "httprb"],
       "rails"         => ["active_record", "rails"],
       "serialization" => ["json", "marshalling", "yajl"],
       "sinatra"       => ["sinatra", "padrino"],
+      "rake"          => ["rake"],
 
       "rest"          => []  # Specially handled below
     }

data/test/multiverse/suites/memcached/dalli_test.rb

@@ -29,38 +29,31 @@ if defined?(Dalli)
       end
 
       def test_assign_instance_to_with_ip_and_port
-        NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
         segment = mock('datastore_segment')
-        segment.expects(:host=).with('jonan.pizza_cube')
-        segment.expects(:port_path_or_id=).with(11211)
+        segment.expects(:set_instance_info).with('127.0.0.1', 11211)
         server = ::Dalli::Server.new '127.0.0.1:11211'
         ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
       end
 
       def test_assign_instance_to_with_name_and_port
-        NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
         segment = mock('datastore_segment')
-        segment.expects(:host=).with('jonan.gummy_planet')
-        segment.expects(:port_path_or_id=).with(11211)
+        segment.expects(:set_instance_info).with('jonan.gummy_planet', 11211)
         server = ::Dalli::Server.new 'jonan.gummy_planet:11211'
         ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
       end
 
       def test_assign_instance_to_with_unix_domain_socket
-        NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
         segment = mock('datastore_segment')
-        segment.expects(:host=).with('jonan.pizza_cube')
-        segment.expects(:port_path_or_id=).with('/tmp/jonanfs.sock')
+        segment.expects(:set_instance_info).with('localhost', '/tmp/jonanfs.sock')
         server = ::Dalli::Server.new '/tmp/jonanfs.sock'
         ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
       end
 
       def test_assign_instance_to_when_exception_raised
-        NewRelic::Agent::Hostname.stubs(:get).raises("oops")
         segment = mock('datastore_segment')
-        segment.expects(:host=).with('unknown')
-        segment.expects(:port_path_or_id=).with('unknown')
+        segment.expects(:set_instance_info).with('unknown', 'unknown')
         server = ::Dalli::Server.new '/tmp/jonanfs.sock'
+        server.stubs(:hostname).raises("oops")
         ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
       end
 

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

@@ -30,6 +30,10 @@ class ResqueTest < Minitest::Test
       sleep sleep_duration
       @count += 1
     end
+
+    def self.request(args)
+      "we are not amused"
+    end
   end
 
   JOB_COUNT = 5

data/test/multiverse/suites/sidekiq/sidekiq_server.rb

@@ -8,6 +8,8 @@ require 'sidekiq/cli'
 class SidekiqServer
   include Singleton
 
+  THREAD_JOIN_TIMEOUT = 30
+
   attr_reader :queue_name
 
   def initialize
@@ -26,6 +28,8 @@ class SidekiqServer
   def stop
     puts "Trying to stop Sidekiq gracefully from #{$$}"
     Process.kill("INT", $$)
-    @cli_thread.join
+    if @cli_thread.join(THREAD_JOIN_TIMEOUT).nil?
+      puts "#{$$} Sidekiq::CLI thread timeout on exit"
+    end
   end
 end

data/test/multiverse/suites/sinatra/Envfile

@@ -1,3 +1,11 @@
+if RUBY_VERSION >= '2.2.0'
+  gemfile <<-RB
+    gem 'sinatra', '~> 2.0.0.beta2'
+    gem 'rack',    '~> 2.0.0'
+    gem 'rack-test', :require => 'rack/test'
+  RB
+end
+
 gemfile <<-RB
   gem 'sinatra', '~> 1.4.6'
   gem 'rack',    '~> 1.5.0'

data/test/multiverse/suites/sinatra/sinatra_error_tracing_test.rb

@@ -40,7 +40,7 @@ class SinatraErrorTracingTest < Minitest::Test
   def test_ignores_notfound_errors_by_default
     get '/ignored_boom'
     assert_equal 404, last_response.status
-    assert_match %r{Sinatra doesn&rsquo;t know this ditty\.}, last_response.body
+    assert_match %r{Sinatra doesn(&rsquo;|’)t know this ditty\.}, last_response.body
 
     errors = harvest_error_traces!
     assert_equal(0, errors.size)

data/test/multiverse/suites/sinatra/sinatra_test_cases.rb

@@ -21,9 +21,15 @@ module SinatraTestCases
       'GET /route/no_match'
     end
 
-    # get /\/regex.*/
-    def regex_segment
-      'GET (?-mix:\/regex.*)'
+    if NewRelic::VersionNumber.new(Sinatra::VERSION).major_version < 2
+      # get /\/regex.*/
+      def regex_segment
+        'GET (?-mix:\/regex.*)'
+      end
+    else
+      def regex_segment
+        'GET \/regex.*'
+      end
     end
 
     # get '/precondition'
@@ -178,25 +184,37 @@ module SinatraTestCases
   end
 
   def test_rack_request_params_errors_are_swallowed
-    fail_on_second_params_call
+    trigger_error_on_params
 
     get '/pass'
-    assert_equal 200, last_response.status
+
+    expected_status = NewRelic::VersionNumber.new(Sinatra::VERSION).major_version < 2 ? 200 : 400
+
+    assert_equal expected_status, last_response.status
   end
 
   def test_rack_request_params_errors_are_logged
     NewRelic::Agent.logger.stubs(:debug)
     NewRelic::Agent.logger.expects(:debug).with("Failed to get params from Rack request.", kind_of(StandardError)).at_least_once
 
-    fail_on_second_params_call
+    trigger_error_on_params
 
     get '/pass'
   end
 
-  def fail_on_second_params_call
-    Sinatra::Request.any_instance.
+
+  if NewRelic::VersionNumber.new(Sinatra::VERSION).major_version < 2
+    def trigger_error_on_params
+      Sinatra::Request.any_instance.
       stubs(:params).returns({}).
-      then.raises("Rack::Request#params error")
+      then.raises(StandardError.new "Rack::Request#params error")
+    end
+  else
+    def trigger_error_on_params
+      Sinatra::Request.any_instance.
+      stubs(:params).
+      raises(Sinatra::BadRequest.new)
+    end
   end
 
   def test_root_path_naming

data/test/multiverse/suites/typhoeus/Envfile

@@ -13,6 +13,11 @@ gemfile <<-RB
 
   # We try translating URIs through Addressable if it's there, so test with it.
   gem 'addressable', :require => 'addressable/uri'
+  if RUBY_VERSION < '1.9.3'
+    gem 'public_suffix', '< 1.4'
+  elsif RUBY_VERSION < '2.0'
+    gem 'public_suffix', '< 1.5'
+  end
 RB
 
 gemfile <<-RB

data/test/new_relic/agent/api_tests/datastore_api_test.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/transaction'
+
+module NewRelic
+  module Agent
+    class DatastoreApiTest < Minitest::Test
+      def setup
+        freeze_time
+        NewRelic::Agent.drop_buffered_data
+      end
+
+      load_cross_agent_test('datastores/datastore_api').each do |test|
+        define_method :"test_#{test['test_name'].tr(' ', '_')}" do
+          NewRelic::Agent::Hostname.stubs(:get).returns(test['input']['system_hostname'])
+
+          params = test['input']['parameters']
+          txn_helper_method = test['input']['is_web'] ? :in_web_transaction : :in_background_transaction
+          config = test['input']['configuration'].merge(:disable_harvest_thread => true)
+
+          with_config config do
+            send(txn_helper_method) do
+              segment = NewRelic::Agent::Transaction.start_datastore_segment(
+                params['product'], params['operation'], params['collection'],
+                params['host'], params['port_path_or_id'], params['database_name']
+              )
+              segment.notice_sql "select * from foo"
+              advance_time 2.0
+              segment.finish
+            end
+
+            host, port_path_or_id, database_name =
+              test['expectation']['transaction_segment_and_slow_query_trace'].values_at('host', 'port_path_or_id', 'database_name')
+
+            segment_name = test['expectation']['metrics_scoped'][0]
+
+            assert_metrics_recorded test['expectation']['metrics_unscoped']
+            assert_expected_tt_segment_params segment_name, host, port_path_or_id, database_name
+            assert_expected_slow_sql_params host, port_path_or_id, database_name
+          end
+        end
+      end
+
+      def assert_expected_tt_segment_params segment_name, host, port_path_or_id, database_name
+        trace = last_transaction_trace
+        segment = find_node_with_name trace, segment_name
+
+        assert_equal host, segment[:host]
+        assert_equal port_path_or_id, segment[:port_path_or_id]
+        assert_equal database_name, segment[:database_name]
+      end
+
+      def assert_expected_slow_sql_params host, port_path_or_id, database_name
+        sql_trace = last_sql_trace
+
+        assert_equal host, sql_trace.params[:host]
+        assert_equal port_path_or_id, sql_trace.params[:port_path_or_id]
+        assert_equal database_name, sql_trace.params[:database_name]
+      end
+    end
+  end
+end

data/test/new_relic/agent/configuration/default_source_test.rb

@@ -35,13 +35,16 @@ module NewRelic::Agent::Configuration
       NewRelic::Control.instance.local_env.stubs(:discovered_dispatcher).returns(:unicorn)
 
       @default_source.keys.each do |key|
-        actual_type = get_config_value_class(fetch_config_value(key))
+        config_value = fetch_config_value(key)
+        actual_type = get_config_value_class(config_value)
         expected_type = @defaults[key][:type]
 
         if @defaults[key][:allow_nil]
-          assert [NilClass, expected_type].include?(actual_type), "Default value for #{key} should be NilClass or #{expected_type}, is #{actual_type}."
+          assertion = (NilClass === config_value) || (expected_type === config_value)
+          assert assertion, "Default value for #{key} should be NilClass or #{expected_type}, is #{actual_type}."
         else
-          assert_equal expected_type, actual_type, "Default value for #{key} should be #{expected_type}, is #{actual_type}."
+          assertion = expected_type === config_value
+          assert assertion, "Default value for #{key} should be #{expected_type}, is #{actual_type}."
         end
       end
     end

data/test/new_relic/agent/instrumentation/active_record_subscriber_test.rb

@@ -61,6 +61,22 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Minitest::T
     assert_metrics_recorded('Datastore/instance/MySQL/jonan.gummy_planet/3306')
   end
 
+  def test_records_datastore_instance_metric_with_one_datum_missing
+    config = { :adapter => "mysql", :host => "jonan.gummy_planet", :port => "" }
+    @subscriber.stubs(:active_record_config).returns(config)
+
+    simulate_query(2)
+
+    assert_metrics_recorded('Datastore/instance/MySQL/jonan.gummy_planet/unknown')
+
+    config = { :adapter => "mysql", :host => "", :port => 3306 }
+    @subscriber.stubs(:active_record_config).returns(config)
+
+    simulate_query(2)
+
+    assert_metrics_recorded('Datastore/instance/MySQL/unknown/3306')
+  end
+
   def test_does_not_record_datastore_instance_metric_for_unsupported_adapter
     config = { :adapter => "JonanDB", :host => "jonan.gummy_planet" }
     @subscriber.stubs(:active_record_config).returns(config)
@@ -81,6 +97,15 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Minitest::T
     end
   end
 
+  def test_does_not_record_datastore_instance_metric_if_both_are_empty
+    config = { :adapter => "", :host => "" }
+    @subscriber.stubs(:active_record_config).returns(config)
+
+    simulate_query(2)
+
+    assert_metrics_not_recorded('Datastore/instance/unknown/unknown')
+  end
+
   def test_does_not_record_database_name_if_disabled
     config = { :host => "jonan.gummy_planet", :database => "pizza_cube" }
     @subscriber.stubs(:active_record_config).returns(config)
@@ -93,8 +118,9 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Minitest::T
   end
 
   def test_records_unknown_unknown_when_error_gathering_instance_data
-    NewRelic::Agent::Hostname.stubs(:get).raises StandardError.new
+    NewRelic::Agent::Instrumentation::ActiveRecordHelper::InstanceIdentification.stubs(:postgres_unix_domain_socket_case?).raises StandardError.new
     NewRelic::Agent::Instrumentation::ActiveRecordHelper::InstanceIdentification.stubs(:mysql_default_case?).raises StandardError.new
+
     config = {:adapter => 'mysql', :host => "127.0.0.1"}
     @subscriber.stubs(:active_record_config).returns(config)
 

data/test/new_relic/agent/instrumentation/instance_identification_test.rb

@@ -24,12 +24,11 @@ module NewRelic
           end
 
           def test_for_constructs_id_with_unspecified_configuration
-            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
             config = {}
             host = InstanceIdentification.host(config)
             ppid = InstanceIdentification.port_path_or_id(config)
 
-            assert_equal "jonan.pizza_cube", host
+            assert_equal "localhost", host
             assert_equal "default", ppid
           end
 
@@ -57,30 +56,15 @@ module NewRelic
           end
 
           def test_for_constructs_id_with_port_without_host
-            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
             config = { :port => 1337 }
 
             host = InstanceIdentification.host(config)
             ppid = InstanceIdentification.port_path_or_id(config)
 
-            assert_equal "jonan.pizza_cube", host
+            assert_equal "localhost", host
             assert_equal "1337", ppid
           end
 
-          def test_for_constructs_id_with_detected_localhost
-            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
-
-            %w[localhost 0.0.0.0 127.0.0.1 0:0:0:0:0:0:0:1 0:0:0:0:0:0:0:0 ::1 ::].each do |host|
-              config = { :host => host }
-
-              host = InstanceIdentification.host(config)
-              ppid = InstanceIdentification.port_path_or_id(config)
-
-              assert_equal "jonan.pizza_cube", host
-              assert_equal "default", ppid
-            end
-          end
-
           def test_for_constructs_id_with_default_port
             config = {
               :adapter => "mysql",
@@ -95,7 +79,6 @@ module NewRelic
           end
 
           def test_for_constructs_id_with_postgres_directory
-            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
             config = {
               :adapter => "postgresql",
               :host => "/tmp"
@@ -104,12 +87,11 @@ module NewRelic
             host = InstanceIdentification.host(config)
             ppid = InstanceIdentification.port_path_or_id(config)
 
-            assert_equal "jonan.pizza_cube", host
+            assert_equal "localhost", host
             assert_equal "default", ppid
           end
 
           def test_for_constructs_id_with_mysql_socket
-            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
             %w[ mysql mysql2 jdbcmysql ].each do |adapter|
               config = {
                 :adapter => adapter,
@@ -119,7 +101,7 @@ module NewRelic
               host = InstanceIdentification.host(config)
               ppid = InstanceIdentification.port_path_or_id(config)
 
-              assert_equal "jonan.pizza_cube", host
+              assert_equal "localhost", host
               assert_equal "/var/run/mysqld.sock", ppid
             end
           end