newrelic_rpm 3.9.6.257 → 3.9.7.266

data/test/new_relic/fake_external_server.rb

@@ -54,16 +54,12 @@ module NewRelic
         result
       end
     end
-
-    def fallback_port
-      # Only use fallback port on the FakeCollector....
-      nil
-    end
   end
 
   class FakeSecureExternalServer < FakeExternalServer
     def initialize
-      super(0, true)
+      super(0)
+      self.use_ssl = true
     end
   end
 end

data/test/new_relic/fake_server.rb

@@ -19,7 +19,7 @@ module NewRelic
     # Default server options
     DEFAULT_OPTIONS = {
       :Logger    => ::WEBrick::Log.new('/dev/null'),
-      :AccessLog => [ ['/dev/null', ''] ]
+      :AccessLog => [['/dev/null', '']]
     }
 
     CONFIG_PATH        = File.join(File.dirname(__FILE__), "..", "config")
@@ -27,61 +27,78 @@ module NewRelic
     FAKE_SSL_KEY_PATH  = File.join(CONFIG_PATH, "test.cert.key")
 
     SSL_OPTIONS = {
-      :SSLEnable => true,
+      :SSLEnable       => true,
       :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE,
-      :SSLPrivateKey => OpenSSL::PKey::RSA.new(File.read(FAKE_SSL_KEY_PATH)),
-      :SSLCertificate => OpenSSL::X509::Certificate.new(File.read(FAKE_SSL_CERT_PATH)),
-      :SSLCertName => [["CN", "newrelic.com"]]
+      :SSLPrivateKey   => OpenSSL::PKey::RSA.new(File.read(FAKE_SSL_KEY_PATH)),
+      :SSLCertificate  => OpenSSL::X509::Certificate.new(File.read(FAKE_SSL_CERT_PATH)),
+      :SSLCertName     => [["CN", "newrelic.com"]]
     }
 
-    def initialize( port=DEFAULT_PORT, ssl=false )
-      @thread = nil
-
-      defaults = $DEBUG ? {} : DEFAULT_OPTIONS
-      @options = defaults.merge( :Port => port )
+    def initialize(port=DEFAULT_PORT)
+      @port    = port
+      @thread  = nil
+      @sever   = nil
+      @use_ssl = false
+    end
 
-      @options.merge!(SSL_OPTIONS) if ssl
+    def use_ssl=(value)
+      @use_ssl = value
+    end
 
-      @server = WEBrick::HTTPServer.new( @options )
-      @server.mount "/", ::Rack::Handler.get( :webrick ), app
+    def use_ssl?
+      @use_ssl
     end
 
+    def needs_restart?
+      @started_options != build_webrick_options
+    end
 
-    attr_reader :server
+    def restart
+      stop
+      run
+    end
 
-    # Run the server, returning the Thread it is running in.
-    def run( port=nil )
-      return if @thread && @thread.alive?
-      @server.listen( @options[:BindAddress], port ) if port
-      @thread = Thread.new( &self.method(:run_server) )
-      return @thread
+    def running?
+      @thread && @thread.alive?
     end
 
+    def run
+      return if running?
 
-    # Thread routine for running the server.
-    def run_server
-      Thread.current.abort_on_exception = true
-      @server.start
-    end
+      @started_options = build_webrick_options
 
+      @server = WEBrick::HTTPServer.new(@started_options)
+      @server.mount "/", ::Rack::Handler.get(:webrick), app
+
+      @thread = Thread.new(&self.method(:run_server))
+    end
 
     def stop
-      return unless @thread.alive?
+      return unless running?
       @server.shutdown
       @server = nil
       @thread.join
+      @started_options = nil
       reset
     end
 
+    def build_webrick_options
+      options = DEFAULT_OPTIONS.merge(:Port => @port)
+      options.merge!(SSL_OPTIONS) if use_ssl?
+      options
+    end
+
+    def run_server
+      Thread.current.abort_on_exception = true
+      @server.start
+    end
 
     def ports
-      @server.listeners.map {|sock| sock.addr[1] }
+      @server.listeners.map { |sock| sock.addr[1] }
     end
 
     def port
       self.ports.first
     end
-    alias_method :determine_port, :port
-
   end
 end

data/test/new_relic/http_client_test_cases.rb

@@ -32,8 +32,7 @@ module HttpClientTestCases
     $fake_secure_server.run
 
     NewRelic::Agent.instance.events.notify(:finished_configuring)
-
-    @engine = NewRelic::Agent.instance.stats_engine
+    NewRelic::Agent::CrossAppTracing.instance_variable_set(:@obfuscator, nil)
   end
 
   # Helpers to support shared tests
@@ -476,6 +475,28 @@ module HttpClientTestCases
     end
   end
 
+  def test_raw_synthetics_header_is_passed_along_if_present
+    with_config(:"cross_application_tracer.enabled" => true) do
+      in_transaction do
+        state = NewRelic::Agent::TransactionState.tl_get
+        state.current_transaction.raw_synthetics_header = "boo"
+
+        get_response
+
+        assert_equal "boo", server.requests.last["HTTP_X_NEWRELIC_SYNTHETICS"]
+      end
+    end
+  end
+
+  def test_no_raw_synthetics_header_if_not_present
+    with_config(:"cross_application_tracer.enabled" => true) do
+      in_transaction do
+        get_response
+        refute_includes server.requests.last.keys, "HTTP_X_NEWRELIC_SYNTHETICS"
+      end
+    end
+  end
+
   load_cross_agent_test("cat_map").each do |test_case|
     # Test cases that don't involve outgoing calls are done elsewhere
     if test_case['outboundRequests']
@@ -485,6 +506,8 @@ module HttpClientTestCases
           :'cross_application_tracer.enabled' => true
         }
         with_config(config) do
+          NewRelic::Agent.instance.events.notify(:finished_configuring)
+
           in_transaction do
             state = NewRelic::Agent::TransactionState.tl_get
             state.referring_transaction_info = test_case['inboundPayload']
@@ -513,6 +536,52 @@ module HttpClientTestCases
     end
   end
 
+  # These tests only cover receiving, validating, and passing on the synthetics
+  # request header to any outgoing HTTP requests. They do *not* cover attaching
+  # of appropriate data to analytics events or transaction traces.
+  #
+  # The tests in agent_only/synthetics_test.rb cover that.
+  load_cross_agent_test('synthetics/synthetics').each do |test|
+    define_method("test_synthetics_http_#{test['name']}") do
+      config = {
+        :encoding_key        => test['settings']['agentEncodingKey'],
+        :trusted_account_ids => test['settings']['trustedAccountIds'],
+        :'cross_application_tracer.enabled' => true
+      }
+
+      with_config(config) do
+        NewRelic::Agent.instance.events.notify(:finished_configuring)
+
+        fake_rack_env = {}
+        test['inputObfuscatedHeader'].each do |key, value|
+          fake_rack_env[http_header_name_to_rack_key(key)] = value
+        end
+
+        in_transaction do
+          NewRelic::Agent.agent.events.notify(:before_call, fake_rack_env)
+          get_response
+
+          last_outbound_request = server.requests.last
+          header_specs = test['outputExternalRequestHeader']
+
+          header_specs['expectedHeader'].each do |key, value|
+            expected_key = http_header_name_to_rack_key(key)
+            assert_equal(value, last_outbound_request[expected_key])
+          end
+
+          header_specs['nonExpectedHeader'].each do |key|
+            non_expected_key = http_header_name_to_rack_key(key)
+            refute_includes(last_outbound_request.keys, non_expected_key)
+          end
+        end
+      end
+    end
+  end
+
+  def http_header_name_to_rack_key(name)
+    "HTTP_" + name.upcase.gsub('-', '_')
+  end
+
   def make_app_data_payload( *args )
     obfuscator = NewRelic::Agent::Obfuscator.new('gringletoes')
     return obfuscator.obfuscate( args.to_json ) + "\n"

data/test/new_relic/local_environment_test.rb

@@ -22,4 +22,82 @@ class NewRelic::LocalEnvironmentTest < Minitest::Test
       end
     end
   end
+
+  def test_not_resque
+    combinations = [["notrake", "resque:work",    { "QUEUE" => "*" } ],
+                    ["rake",    "notresque:work", { "QUEUE" => "*" } ],
+                    ["rake",    "resque:work",    { "BBQ"   => "*" } ]]
+
+    combinations.each do |settings|
+      with_resque(*settings) do
+        refute_resque(settings)
+      end
+    end
+  end
+
+  def test_resque
+    combinations = [["rake", "resque:work", { "QUEUE"  => "*" }],
+                    ["rake", "resque:work", { "QUEUES" => "*" }]]
+
+    combinations.each do |settings|
+      with_resque(*settings) do
+        assert_resque(settings)
+      end
+    end
+  end
+
+  def test_not_resque_pool
+    combinations = [["notresque-pool", nil],
+                    ["rake", "notresque:pool"]]
+
+    combinations.each do |settings|
+      with_resque_pool(*settings) do
+        refute_resque(settings)
+      end
+    end
+  end
+
+  def test_resque_pool
+    combinations = [["resque-pool", nil],
+                    ["rake", "resque:pool"]]
+
+    combinations.each do |settings|
+      with_resque_pool(*settings) do
+        assert_resque(settings)
+      end
+    end
+  end
+
+  def with_resque(basename, *args)
+    env  = {}
+    env  = args.last if args.last.is_a?(Hash)
+    argv = args[0..-1]
+
+    with_constant_defined(:Resque) do
+      with_environment(env) do
+        with_argv(argv) do
+          File.stubs(:basename).returns(basename)
+          yield
+        end
+      end
+    end
+  end
+
+  def with_resque_pool(basename, *args)
+    with_resque(basename, *args) do
+      with_constant_defined(:'Resque::Pool') do
+        yield
+      end
+    end
+  end
+
+  def assert_resque(settings)
+    e = NewRelic::LocalEnvironment.new
+    assert_equal :resque, e.discovered_dispatcher, settings.inspect
+  end
+
+  def refute_resque(settings)
+    e = NewRelic::LocalEnvironment.new
+    refute_equal :resque, e.discovered_dispatcher, settings.inspect
+  end
 end

data/test/new_relic/metric_parser/metric_parser_test.rb

@@ -2,6 +2,8 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
+require 'conditional_vendored_metric_parser'
+
 require File.expand_path(File.join(File.dirname(__FILE__),'..', '..', 'test_helper'))
 class NewRelic::MetricParser::MetricParserTest < Minitest::Test
   class ::AnApplicationClass

data/test/new_relic/metric_spec_test.rb

@@ -75,8 +75,51 @@ class NewRelic::MetricSpecTest < Minitest::Test
     assert_equal("b" * 255, spec.scope, "should have shortened the scope")
   end
 
+  # These next three tests are here only because rpm_site uses our MetricSpec
+  # class in silly ways (specifically, it passes in non-String values for
+  # name/scope). If we can get rid of those silly usages, we can remove these
+  # tests.
+
+  def test_initialize_can_take_a_nil_name
+    spec = NewRelic::MetricSpec.new(nil)
+
+    assert_equal('', spec.name)
+    assert_equal('', spec.scope)
+  end
+
+  def test_initialize_can_take_a_non_string_name
+    name  = string_wrapper_class.new("name")
+
+    spec = NewRelic::MetricSpec.new(name)
+
+    assert_equal('name',  spec.name)
+    assert_equal('',      spec.scope)
+  end
+
+  def test_initialize_can_take_a_non_string_scope
+    name  = "name"
+    scope = string_wrapper_class.new("scope")
+
+    spec = NewRelic::MetricSpec.new(name, scope)
+
+    assert_equal('name',  spec.name)
+    assert_equal('scope', spec.scope)
+  end
+
   private
 
+  def string_wrapper_class
+    Class.new do
+      def initialize(value)
+        @value = value
+      end
+
+      def to_s
+        @value
+      end
+    end
+  end
+
   def compare_spec(spec, import)
     assert_equal 2, import.length
     assert_equal spec.name, import['name']

data/test/new_relic/multiverse_helpers.rb

@@ -32,19 +32,21 @@ module MultiverseHelpers
   end
 
   def setup_agent(opts = {}, &block)
-    setup_collector
+    ensure_fake_collector unless omit_collector?
 
     # Give caller a shot to setup before we start
-    # Don't just yield, as that won't necessary have the intended receiver
+    # Don't just yield, as that won't necessarily have the intended receiver
     # (the test case instance itself)
     self.instance_exec($collector, &block) if block_given? && self.respond_to?(:instance_exec)
 
+    # It's important that this is called after the insance_exec above, so that
+    # test cases have the chance to change settings on the fake collector first
+    start_fake_collector unless omit_collector?
+
     trigger_agent_reconnect(opts)
   end
 
   def teardown_agent
-    reset_collector
-
     # Put the configs back where they belong....
     NewRelic::Agent.config.reset_to_defaults
 
@@ -99,24 +101,15 @@ module MultiverseHelpers
   # This helps so the runner process can decide before spawning the child
   # whether we want the collector running or not.
 
-  def setup_collector(use_ssl=false)
-    return if omit_collector?
-
+  def ensure_fake_collector
     require 'fake_collector'
-    $collector ||= NewRelic::FakeCollector.new(use_ssl)
+    $collector ||= NewRelic::FakeCollector.new
     $collector.reset
-    $collector.run
-
-    if (NewRelic::Agent.instance &&
-        NewRelic::Agent.instance.service &&
-        NewRelic::Agent.instance.service.collector)
-      NewRelic::Agent.instance.service.collector.port = $collector.port
-    end
   end
 
-  def reset_collector
-    return if omit_collector?
-    $collector.reset
+  def start_fake_collector
+    $collector.restart if $collector.needs_restart?
+    agent.service.collector.port = $collector.port if agent
   end
 
   def omit_collector?

data/test/new_relic/rack/browser_monitoring_test.rb

@@ -66,6 +66,7 @@ EOL
       :'rum.enabled' => true,
       :license_key => 'a' * 40,
       :js_agent_loader => 'loader',
+      :disable_harvest_thread => true
     }
     NewRelic::Agent.config.add_config_for_testing(@config)
   end
@@ -178,24 +179,6 @@ EOL
     assert last_response.ok?
   end
 
-  def test_token_is_set_in_footer_when_set_by_cookie
-    token = '1234567890987654321'
-    set_cookie "NRAGENT=tk=#{token}"
-    get '/'
-
-    assert(last_response.body.include?(token), last_response.body)
-  end
-
-  def test_guid_is_set_in_footer_when_token_is_set
-    guid = 'abcdefgfedcba'
-    NewRelic::Agent::Transaction.any_instance.stubs(:guid).returns(guid)
-    set_cookie "NRAGENT=tk=token"
-    with_config(:apdex_t => 0.0001) do
-      get '/'
-      assert(last_response.body.include?(guid), last_response.body)
-    end
-  end
-
   def test_calculate_content_length_accounts_for_multibyte_characters_for_186
     String.stubs(:respond_to?).with(:bytesize).returns(false)
     browser_monitoring = NewRelic::Rack::BrowserMonitoring.new(mock('app'))