RubyGems - newrelic_rpm - Versions diffs - 4.0.0.332 → 6.13.1 - Mend

newrelic_rpm 4.0.0.332 → 6.13.1

Files changed (1193) hide show

data/test/new_relic/fake_external_server.rb DELETED

@@ -1,65 +0,0 @@
-# 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 'rack'
-require 'new_relic/fake_server'
-require 'new_relic/rack/agent_hooks'
-require 'json'
-module NewRelic
-  class FakeExternalServer < FakeServer
-    STATUS_MESSAGE = "<html><head><title>FakeExternalServer status</title></head>" +
-      "<body>The FakeExternalServer is rockin'</body></html>"
-    attr_reader :overridden_response_headers
-    def initialize( * )
-      super
-      @requests = []
-    end
-    attr_reader :requests
-    def call(env)
-      @requests << env.dup
-      req = ::Rack::Request.new(env)
-      res = ::Rack::Response.new
-      res.status = req.params["status"].to_i if req.params["status"]
-      in_transaction('test') do
-        res.write STATUS_MESSAGE
-      end
-      res.finish
-    end
-    def reset
-      @requests.clear
-      @overridden_response_headers = {}
-    end
-    def override_response_headers(headers)
-      @overridden_response_headers.merge!(headers)
-    end
-    def app
-      inner_app = NewRelic::Rack::AgentHooks.new(self)
-      server = self
-      Proc.new do |env|
-        result = inner_app.call(env)
-        result[1].merge!(server.overridden_response_headers)
-        result
-      end
-    end
-  end
-  class FakeSecureExternalServer < FakeExternalServer
-    def initialize
-      super(0)
-      self.use_ssl = true
-    end
-  end
-end

data/test/new_relic/fake_instance_metadata_service.rb DELETED

@@ -1,45 +0,0 @@
-# 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 'rack'
-require 'rack/request'
-require 'fake_server'
-module NewRelic
-  class FakeInstanceMetadataService < FakeServer
-    def initialize(*_)
-      super
-      reset
-    end
-    def set_response_for_path(path, response)
-      @responses[path] = response
-    end
-    def response_for_path(path)
-      @responses[path]
-    end
-    def call(env)
-      req  = ::Rack::Request.new(env)
-      path = req.path
-      rsp  = response_for_path(path)
-      case rsp
-      when ::Rack::Response
-        rsp.to_a
-      when String
-        [200, {}, [rsp]]
-      end
-    end
-    def reset
-      @responses = {}
-    end
-    def app
-      self
-    end
-  end
-end

data/test/new_relic/fake_rpm_site.rb DELETED

@@ -1,35 +0,0 @@
-# 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 'rack'
-require 'rack/request'
-require 'fake_server'
-module NewRelic
-  class FakeRpmSite < FakeServer
-    def initialize(*_)
-      super
-      @requests = []
-    end
-    attr_reader :requests
-    def call(env)
-      @requests << unpack(env)
-      [200, {}, ["Fine"]]
-    end
-    def unpack(env)
-      ::Rack::Request.new(env).params
-    end
-    def reset
-      @requests.clear
-    end
-    def app
-      self
-    end
-  end
-end

data/test/new_relic/fake_server.rb DELETED

@@ -1,104 +0,0 @@
-# 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 'webrick'
-require 'webrick/https'
-require 'rack'
-require 'rack/handler'
-require 'timeout'
-require 'json'
-module NewRelic
-  class FakeServer
-    # Use ephemeral ports by default
-    DEFAULT_PORT = 0
-    # Default server options
-    DEFAULT_OPTIONS = {
-      :Logger    => ::WEBrick::Log.new('/dev/null'),
-      :AccessLog => [['/dev/null', '']]
-    }
-    CONFIG_PATH        = File.join(File.dirname(__FILE__), "..", "config")
-    FAKE_SSL_CERT_PATH = File.join(CONFIG_PATH, "test.cert.crt")
-    FAKE_SSL_KEY_PATH  = File.join(CONFIG_PATH, "test.cert.key")
-    SSL_OPTIONS = {
-      :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"]]
-    }
-    def initialize(port=DEFAULT_PORT)
-      @port    = port
-      @thread  = nil
-      @sever   = nil
-      @use_ssl = false
-    end
-    def use_ssl=(value)
-      @use_ssl = value
-    end
-    def use_ssl?
-      @use_ssl
-    end
-    def needs_restart?
-      @started_options != build_webrick_options
-    end
-    def restart
-      stop
-      run
-    end
-    def running?
-      @thread && @thread.alive?
-    end
-    def run
-      return if running?
-      @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 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] }
-    end
-    def port
-      self.ports.first
-    end
-  end
-end

data/test/new_relic/filtering_test_app.rb DELETED

@@ -1,19 +0,0 @@
-# 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.
-# This is a simple test app for testing parameter filtering as provided by
-# the NewRelic::Agent:ParameterFiltering module.
-class FilteringTestApp
-  def call(env)
-    req = Rack::Request.new(env)
-    txn = ::NewRelic::Agent::Transaction.tl_current
-    params = req.params
-    filtered = ::NewRelic::Agent::ParameterFiltering.apply_filters(env, params)
-    txn.filtered_params = filtered
-    txn.merge_request_parameters(filtered)
-    raise "Intentional error" if params["raise"]
-    [200, {}, ["Filters applied"]]
-  end
-end

data/test/new_relic/framework_test.rb DELETED

@@ -1,58 +0,0 @@
-# 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'))
-# Test logic around detecting or configuring framework
-class FrameworkTest < Minitest::Test
-  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)
-    NewRelic::Agent.reset_config
-  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

data/test/new_relic/http_client_test_cases.rb DELETED

@@ -1,639 +0,0 @@
-# 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 "newrelic_rpm"
-require "fake_external_server"
-require "evil_server"
-module HttpClientTestCases
-  include NewRelic::Agent::Instrumentation::ControllerInstrumentation,
-          NewRelic::Agent::CrossAppTracing,
-          MultiverseHelpers
-  TRANSACTION_GUID = 'BEC1BC64675138B9'
-  $fake_server = NewRelic::FakeExternalServer.new
-  $fake_secure_server = NewRelic::FakeSecureExternalServer.new
-  setup_and_teardown_agent(
-      :"cross_application_tracer.enabled" => false,
-      :cross_process_id                   => "269975#22824",
-      :encoding_key                       => "gringletoes",
-      :trusted_account_ids                => [269975]
-    )
-  def after_setup
-    $fake_server.reset
-    $fake_server.run
-    $fake_secure_server.reset
-    $fake_secure_server.run
-    NewRelic::Agent.instance.events.notify(:finished_configuring)
-    NewRelic::Agent::CrossAppTracing.instance_variable_set(:@obfuscator, nil)
-  end
-  # Helpers to support shared tests
-  def use_ssl?
-    @ssl
-  end
-  def server
-    @ssl ? $fake_secure_server : $fake_server
-  end
-  def protocol
-    @ssl ? "https" : "http"
-  end
-  def default_url
-    "#{protocol}://localhost:#{server.port}/status"
-  end
-  def default_uri
-    URI.parse(default_url)
-  end
-  def body(res)
-    res.body
-  end
-  # Tests
-  def test_validate_request_wrapper
-    req = request_instance
-    req.respond_to?(:type)
-    req.respond_to?(:host)
-    req.respond_to?(:method)
-    req.respond_to?(:[])
-    req.respond_to?(:[]=)
-    req.respond_to?(:uri)
-  end
-  def test_validate_response_wrapper
-    res = response_instance
-    res.respond_to?(:[])
-    res.respond_to?(:to_hash)
-  end
-  # Some libraries (older Typhoeus), have had odd behavior around [] for
-  # missing keys. This generates log messages, although it behaves right in
-  # terms of metrics, so double-check we get what we expect
-  def test_request_headers_for_missing_key
-    assert_nil request_instance["boo"]
-  end
-  def test_response_headers_for_missing_key
-    assert_nil response_instance["boo"]
-  end
-  def test_response_wrapper_ignores_case_in_header_keys
-    res = response_instance('NAMCO' => 'digdug')
-    assert_equal 'digdug', res['namco']
-  end
-  def test_get
-    res = nil
-    in_transaction { res = get_response }
-    assert_match %r/<head>/i, body(res)
-    assert_externals_recorded_for("localhost", "GET")
-  end
-  # Although rare, some clients do explicitly set the "host" header on their
-  # http requests. Respect that rather than the host IP on the request if so.
-  #
-  # https://github.com/newrelic/rpm/pull/124
-  def test_get_with_host_header
-    uri = default_uri
-    uri.host = '127.0.0.1'
-    res = nil
-    in_transaction do
-      res = get_response(uri.to_s, 'Host' => 'test.local')
-    end
-    assert_match %r/<head>/i, body(res)
-    assert_externals_recorded_for("test.local", "GET")
-  end
-  def test_get_with_host_header_lowercase
-    uri = default_uri
-    uri.host = '127.0.0.1'
-    res = nil
-    in_transaction do
-      res = get_response(uri.to_s, 'host' => 'test.local')
-    end
-    assert_match %r/<head>/i, body(res)
-    assert_externals_recorded_for("test.local", "GET")
-  end
-  # Only some HTTP clients support explicit connection reuse, so this test
-  # checks whether the host responds to get_response_multi before executing.
-  def test_get_with_reused_connection
-    if self.respond_to?(:get_response_multi)
-      n = 2
-      responses = nil
-      in_transaction do
-        responses = get_response_multi(default_url, n)
-      end
-      responses.each do |res|
-        assert_match %r/<head>/i, body(res)
-      end
-      expected = { :call_count => n }
-      assert_externals_recorded_for("localhost", "GET", :counts => expected)
-    end
-  end
-  def test_background
-    res = nil
-    perform_action_with_newrelic_trace(:name => "task", :category => :task) do
-      res = get_response
-    end
-    assert_match %r/<head>/i, body(res)
-    assert_externals_recorded_for("localhost", "GET")
-    assert_metrics_recorded([
-      ["External/localhost/#{client_name}/GET", "OtherTransaction/Background/#{self.class.name}/task"],
-      "OtherTransaction/Background/#{self.class.name}/task",
-      "OtherTransaction/Background/all",
-      "OtherTransaction/all"
-    ])
-  end
-  def test_transactional_metrics
-    res = nil
-    perform_action_with_newrelic_trace(:name => "task") do
-      res = get_response
-    end
-    assert_match %r/<head>/i, body(res)
-    assert_externals_recorded_for("localhost", "GET", :transaction_type => "Web")
-    assert_metrics_recorded([
-      "Controller/#{self.class.name}/task"
-    ])
-    assert_metrics_not_recorded([
-      "External/allOther"
-    ])
-  end
-  def test_transactional_traces_nodes
-    perform_action_with_newrelic_trace(:name => "task") do
-      get_response
-      last_node = find_last_transaction_node()
-      assert_equal "External/localhost/#{client_name}/GET", last_node.metric_name
-    end
-  end
-  def test_ignore
-    in_transaction do
-      NewRelic::Agent.disable_all_tracing do
-        post_response
-      end
-    end
-    assert_metrics_recorded([])
-  end
-  def test_head
-    in_transaction { head_response }
-    assert_externals_recorded_for("localhost", "HEAD")
-  end
-  def test_post
-    in_transaction { post_response }
-    assert_externals_recorded_for("localhost", "POST")
-  end
-  def test_put
-    in_transaction { put_response }
-    assert_externals_recorded_for("localhost", "PUT")
-  end
-  def test_delete
-    in_transaction { delete_response }
-    assert_externals_recorded_for("localhost", "DELETE")
-  end
-  if defined?(::Addressable)
-    def test_url_not_supported_by_stdlib_uri
-      res = nil
-      in_transaction do
-        res = get_response("#{protocol}://foo:^password*12@localhost:#{server.port}/status")
-      end
-      assert_match %r/<head>/i, body(res)
-      assert_externals_recorded_for("localhost", "GET")
-    end
-  end
-  # When an http call is made, the agent should add a request header named
-  # X-NewRelic-ID with a value equal to the encoded cross_app_id.
-  def test_adds_a_request_header_to_outgoing_requests_if_xp_enabled
-    with_config(:"cross_application_tracer.enabled" => true) do
-      in_transaction { get_response }
-      assert_equal "VURQV1BZRkZdXUFT", server.requests.last["HTTP_X_NEWRELIC_ID"]
-    end
-  end
-  def test_adds_a_request_header_to_outgoing_requests_if_old_xp_config_is_present
-    with_config(:cross_application_tracing => true) do
-      in_transaction { get_response }
-      assert_equal "VURQV1BZRkZdXUFT", server.requests.last["HTTP_X_NEWRELIC_ID"]
-    end
-  end
-  def test_adds_newrelic_transaction_header
-    with_config(:cross_application_tracing => true) do
-      guid      = nil
-      path_hash = nil
-      in_transaction do |txn|
-        guid      = txn.guid
-        path_hash = txn.cat_path_hash(NewRelic::Agent::TransactionState.tl_get)
-        get_response
-      end
-      transaction_data = server.requests.last["HTTP_X_NEWRELIC_TRANSACTION"]
-      refute_empty(transaction_data)
-      decoded = decode_payload(transaction_data)
-      assert_equal(guid,      decoded[0])
-      assert_equal(false,     decoded[1])
-      assert_equal(guid,      decoded[2])
-      assert_equal(path_hash, decoded[3])
-    end
-  end
-  def test_agent_doesnt_add_a_request_header_to_outgoing_requests_if_xp_disabled
-    in_transaction { get_response }
-    assert_equal false, server.requests.last.keys.any? {|k| k =~ /NEWRELIC_ID/}
-  end
-  def test_agent_doesnt_add_a_request_header_if_empty_cross_process_id
-    with_config(:'cross_application_tracer.enabled' => true,
-                :cross_process_id => "") do
-      in_transaction { get_response }
-      assert_equal false, server.requests.last.keys.any? {|k| k =~ /NEWRELIC_ID/}
-    end
-  end
-  def test_agent_doesnt_add_a_request_header_if_empty_encoding_key
-    with_config(:'cross_application_tracer.enabled' => true,
-                :encoding_key => "") do
-      in_transaction { get_response }
-      assert_equal false, server.requests.last.keys.any? {|k| k =~ /NEWRELIC_ID/}
-    end
-  end
-  def test_instrumentation_with_crossapp_enabled_records_normal_metrics_if_no_header_present
-    $fake_server.override_response_headers('X-NewRelic-App-Data' => '')
-    with_config(:"cross_application_tracer.enabled" => true) do
-      in_transaction("test") do
-        get_response
-      end
-    end
-    assert_externals_recorded_for("localhost", "GET")
-    assert_metrics_recorded([["External/localhost/#{client_name}/GET", "test"]])
-  end
-  def test_instrumentation_with_crossapp_disabled_records_normal_metrics_even_if_header_is_present
-    $fake_server.override_response_headers('X-NewRelic-App-Data' =>
-      make_app_data_payload( "18#1884", "txn-name", 2, 8, 0, TRANSACTION_GUID ))
-    in_transaction("test") do
-      get_response
-    end
-    assert_externals_recorded_for("localhost", "GET")
-    assert_metrics_recorded([["External/localhost/#{client_name}/GET", "test"]])
-  end
-  def test_instrumentation_with_crossapp_enabled_records_crossapp_metrics_if_header_present
-    $fake_server.override_response_headers('X-NewRelic-App-Data' =>
-      make_app_data_payload( "18#1884", "txn-name", 2, 8, 0, TRANSACTION_GUID ))
-    with_config(:"cross_application_tracer.enabled" => true) do
-      in_transaction("test") do
-        get_response
-        last_node = find_last_transaction_node()
-        assert_includes last_node.params.keys, :transaction_guid
-        assert_equal TRANSACTION_GUID, last_node.params[:transaction_guid]
-      end
-    end
-    assert_metrics_recorded([
-      "External/all",
-      "External/allOther",
-      "ExternalApp/localhost/18#1884/all",
-      "ExternalTransaction/localhost/18#1884/txn-name",
-      "External/localhost/all",
-      ["ExternalTransaction/localhost/18#1884/txn-name", "test"]
-    ])
-  end
-  def test_crossapp_metrics_allow_valid_utf8_characters
-    $fake_server.override_response_headers('X-NewRelic-App-Data' =>
-      make_app_data_payload( "12#1114", "世界線航跡蔵", 18.0, 88.1, 4096, TRANSACTION_GUID ))
-    with_config(:"cross_application_tracer.enabled" => true) do
-      in_transaction("test") do
-        get_response
-        last_node = find_last_transaction_node()
-        assert_includes last_node.params.keys, :transaction_guid
-        assert_equal TRANSACTION_GUID, last_node.params[:transaction_guid]
-      end
-    end
-    assert_metrics_recorded([
-      "External/all",
-      "External/allOther",
-      "ExternalApp/localhost/12#1114/all",
-      "External/localhost/all",
-      "ExternalTransaction/localhost/12#1114/世界線航跡蔵",
-      ["ExternalTransaction/localhost/12#1114/世界線航跡蔵", "test"]
-    ])
-  end
-  def test_crossapp_metrics_ignores_crossapp_header_with_malformed_crossprocess_id
-    $fake_server.override_response_headers('X-NewRelic-App-Data' =>
-      make_app_data_payload( "88#88#88", "invalid", 1, 2, 4096, TRANSACTION_GUID ))
-    with_config(:"cross_application_tracer.enabled" => true) do
-      in_transaction("test") do
-        get_response
-      end
-    end
-    assert_externals_recorded_for("localhost", "GET")
-    assert_metrics_recorded([["External/localhost/#{client_name}/GET", "test"]])
-  end
-  def test_doesnt_affect_the_request_if_an_exception_is_raised_while_setting_up_tracing
-    res = nil
-    NewRelic::Agent.instance.stats_engine.stubs( :push_scope ).
-      raises( NoMethodError, "undefined method `push_scope'" )
-    with_config(:"cross_application_tracer.enabled" => true) do
-      in_transaction { res = get_response }
-    end
-    assert_equal NewRelic::FakeExternalServer::STATUS_MESSAGE, body(res)
-  end
-  def test_doesnt_affect_the_request_if_an_exception_is_raised_while_finishing_tracing
-    res = nil
-    NewRelic::Agent.instance.stats_engine.stubs( :pop_scope ).
-      raises( NoMethodError, "undefined method `pop_scope'" )
-    with_config(:"cross_application_tracer.enabled" => true) do
-      in_transaction { res = get_response }
-    end
-    assert_equal NewRelic::FakeExternalServer::STATUS_MESSAGE, body(res)
-  end
-  def test_doesnt_misbehave_when_transaction_tracing_is_disabled
-    # The error should have any other consequence other than logging the error, so
-    # this will capture logs
-    logger = NewRelic::Agent::MemoryLogger.new
-    NewRelic::Agent.logger = logger
-    with_config(:"cross_application_tracer.enabled" => true) do
-      in_transaction { get_response }
-    end
-    refute_match( /undefined method `.*" for nil:NilClass/i,
-                     logger.messages.flatten.map {|log| log.to_s }.join(" ") )
-  end
-  def test_includes_full_url_in_transaction_trace
-    full_url = "#{default_url}?foo=bar#fragment"
-    in_transaction do
-      get_response(full_url)
-      last_node = find_last_transaction_node()
-      filtered_uri = default_url
-      assert_equal filtered_uri, last_node.params[:uri]
-    end
-  end
-  # https://newrelic.atlassian.net/browse/RUBY-1244
-  def test_failure_in_our_start_code_still_records_externals
-    # Fake a failure in our start-up code...
-    ::JSON.stubs(:dump).raises("Boom!")
-    with_config(:"cross_application_tracer.enabled" => true) do
-      in_transaction { get_response }
-    end
-    assert_externals_recorded_for("localhost", "GET")
-  end
-  # https://newrelic.atlassian.net/browse/RUBY-1244
-  def test_failure_to_add_tt_node_doesnt_append_params_to_wrong_node
-    # Fake a failure in our start-up code...
-    ::JSON.stubs(:dump).raises("Boom!")
-    in_transaction do
-      with_config(:"cross_application_tracer.enabled" => true) do
-        get_response
-        last_node = find_last_transaction_node()
-        unless last_node.metric_name.start_with? "External"
-          refute last_node.params.key?(:uri)
-        end
-      end
-    end
-  end
-  def test_still_records_tt_node_when_request_fails
-    # This test does not work on older versions of Typhoeus, because the
-    # on_complete callback is not reliably invoked. That said, it's a corner
-    # case, and the failure mode is just that you lose tracing for the one
-    # transaction in which the error occurs. That, coupled with the fact that
-    # fixing it for old versions of Typhoeus would require large changes to
-    # the instrumentation, makes us say 'meh'.
-    is_typhoeus = (client_name == 'Typhoeus')
-    if !is_typhoeus || (is_typhoeus && Typhoeus::VERSION >= "0.5.4")
-      evil_server = NewRelic::EvilServer.new
-      evil_server.start
-      in_transaction do
-        begin
-          get_response("http://localhost:#{evil_server.port}")
-        rescue
-          # it's expected that this will raise for some HTTP libraries (e.g.
-          # Net::HTTP). we unfortunately don't know the exact exception class
-          # across all libraries
-        end
-        last_node = find_last_transaction_node()
-        assert_equal("External/localhost/#{client_name}/GET", last_node.metric_name)
-      end
-      evil_server.stop
-    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']
-      define_method("test_#{test_case['name']}") do
-        config = {
-          :app_name => test_case['appName'],
-          :'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']
-            stub_transaction_guid(test_case['transactionGuid'])
-            test_case['outboundRequests'].each do |req|
-              set_explicit_transaction_name(req['outboundTxnName'])
-              get_response
-              outbound_payload = server.requests.last["HTTP_X_NEWRELIC_TRANSACTION"]
-              decoded_outbound_payload = decode_payload(outbound_payload)
-              assert_equal(req['expectedOutboundPayload'], decoded_outbound_payload)
-            end
-            set_explicit_transaction_name(test_case['transactionName'])
-          end
-        end
-        event = get_last_analytics_event
-        assert_event_attributes(
-          event,
-          test_case['name'],
-          test_case['expectedIntrinsicFields'],
-          test_case['nonExpectedIntrinsicFields']
-        )
-      end
-    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"
-  end
-  def decode_payload(payload)
-    obfuscator = NewRelic::Agent::Obfuscator.new('gringletoes')
-    ::JSON.load(obfuscator.deobfuscate(payload))
-  end
-  def set_explicit_transaction_name(name)
-    parts = name.split("/")
-    category = parts.shift
-    NewRelic::Agent.set_transaction_name(parts.join('/'), :category => category)
-  end
-  def assert_externals_recorded_for(host, meth, opts={})
-    txn_type   = opts.fetch(:transaction_type, "Other")
-    counts     = opts.fetch(:counts, nil)
-    if counts.nil?
-      assert_metrics_recorded([
-        "External/all",
-        "External/all#{txn_type}",
-        "External/#{host}/#{client_name}/#{meth}",
-        "External/#{host}/all"
-      ])
-    else
-      assert_metrics_recorded(
-        "External/all"                            => counts,
-        "External/all#{txn_type}"                 => counts,
-        "External/#{host}/#{client_name}/#{meth}" => counts,
-        "External/#{host}/all"                    => counts
-      )
-    end
-  end
-end