newrelic_rpm 3.6.4.122 → 3.6.5.130

data/test/new_relic/evil_server.rb

@@ -0,0 +1,56 @@
+# 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 TCP server that binds to an ephemeral port, accepts
+# incoming connections on that port, and then closes those connections
+# immediately thereafter.
+#
+# Its purpose is to emulate a misbehaving HTTP server (or flaky network
+# connection) by closing the TCP connection without sending an HTTP response.
+
+require 'socket'
+
+module NewRelic
+  class EvilServer
+    attr_reader :port, :requests
+
+    def initialize
+      @requests = []
+    end
+
+    def should_run?
+      @state == :running
+    end
+
+    def stop
+      @state = :stopped
+
+      # just a lazy way of just forcing the server to wakeup from accept
+      TCPSocket.open("localhost", @port).close rescue nil
+
+      @thread.join
+      @thread = nil
+    end
+
+    def start
+      return if @thread && @thread.alive?
+      @requests = []
+      @server = TCPServer.new(0)
+      @port = @server.addr[1]
+      @state = :running
+      @thread = Thread.new { run }
+      @thread.abort_on_exception = true
+    end
+
+    def run
+      loop do
+        client = @server.accept
+        @requests << client.readpartial(1024) if should_run?
+        client.close
+        break unless should_run?
+      end
+    end
+  end
+end
+

data/test/new_relic/fake_collector.rb

@@ -8,14 +8,16 @@ require 'uri'
 require 'socket'
 require 'timeout'
 require 'ostruct'
+require 'fake_server'
 
 require 'json' if RUBY_VERSION >= '1.9'
 
 module NewRelic
-  class FakeCollector
+  class FakeCollector < FakeServer
     attr_accessor :agent_data, :mock
 
     def initialize
+      super
       @id_counter = 0
       @base_expectations = {
         'get_redirect_host'       => [200, {'return_value' => 'localhost'}],
@@ -35,10 +37,17 @@ module NewRelic
       @id_counter += 1
     end
 
+    def reset
+      @mock = @base_expectations.dup
+      @id_counter = 0
+      @agent_data = []
+    end
+
     def call(env)
       req = ::Rack::Request.new(env)
       res = ::Rack::Response.new
       uri = URI.parse(req.url)
+
       if uri.path =~ /agent_listener\/\d+\/.+\/(\w+)/
         method = $1
         format = json_format?(uri) && RUBY_VERSION >= '1.9' ? :json : :pruby
@@ -81,85 +90,8 @@ module NewRelic
       uri.query && uri.query.include?('marshal_format=json')
     end
 
-    # 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 => [ ['/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
-          break if !is_port_available?('127.0.0.1', port)
-          sleep 0.01
-        end
-      end
-    end
-
-    def stop
-      return unless @thread.alive?
-      ::Rack::Handler::WEBrick.shutdown
-      @thread.join
-      reset
-    end
-
-    def reset
-      @mock = @base_expectations.dup
-      @id_counter = 0
-      @agent_data = []
-    end
-
-    def is_port_available?(ip, port)
-      begin
-        Timeout::timeout(1) do
-          begin
-            s = TCPSocket.new(ip, port)
-            s.close
-            return false
-          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-            return true
-          end
-        end
-      rescue Timeout::Error
-      end
-
-      return true
+    def app
+      self
     end
 
     def calls_for(method)
@@ -258,22 +190,6 @@ module NewRelic
     end
   end
 
-  # might we need this?  I'll just leave it here for now
-  class FakeCollectorProcess < FakeCollector
-    def run(port)
-      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__

data/test/new_relic/fake_external_server.rb

@@ -0,0 +1,55 @@
+# 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 'fake_server'
+
+require 'json' if RUBY_VERSION >= '1.9'
+
+module NewRelic
+  class FakeExternalServer < FakeServer
+
+    STATUS_MESSAGE = "<html><head><title>FakeExternalServer status</title></head>" +
+      "<body>The FakeExternalServer is rockin'</body></html>"
+
+    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
+    end
+
+    def app
+      NewRelic::Rack::AgentHooks.new(self)
+    end
+
+    def fallback_port
+      # Only use fallback port on the FakeCollector....
+      nil
+    end
+  end
+
+  class FakeSecureExternalServer < FakeExternalServer
+    def initialize
+      super(0, true)
+    end
+  end
+end

data/test/new_relic/fake_server.rb

@@ -0,0 +1,97 @@
+# 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' if RUBY_VERSION >= '1.9'
+
+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")
+
+    SSL_OPTIONS = {
+      :SSLEnable => true,
+      :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE,
+      :SSLPrivateKey => OpenSSL::PKey::RSA.new(File.open(File.join(CONFIG_PATH, "test.cert.key")).read),
+      :SSLCertificate => OpenSSL::X509::Certificate.new(File.open(File.join(CONFIG_PATH, "test.cert.crt")).read),
+      :SSLCertName => [["CN", "newrelic.com"]]
+    }
+
+    def initialize( port=DEFAULT_PORT, ssl=false )
+      @thread = nil
+
+      defaults = $DEBUG ? {} : DEFAULT_OPTIONS
+      @options = defaults.merge( :Port => port )
+
+      @options.merge!(SSL_OPTIONS) if ssl
+
+      @server = WEBrick::HTTPServer.new( @options )
+      @server.mount "/", ::Rack::Handler.get( :webrick ), app
+    end
+
+
+    attr_reader :server
+
+    # 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
+      @server.listen( @options[:BindAddress], fallback_port ) if fallback_port
+      @thread = Thread.new( &self.method(:run_server) )
+      return @thread
+    end
+
+
+    # Thread routine for running the server.
+    def run_server
+      Thread.current.abort_on_exception = true
+      @server.start
+    end
+
+
+    def stop
+      return unless @thread.alive?
+      @server.shutdown
+      @server = nil
+      @thread.join
+      reset
+    end
+
+
+    def ports
+      @server.listeners.map {|sock| sock.addr[1] }
+    end
+
+    def port
+      self.ports.first
+    end
+    alias_method :determine_port, :port
+
+
+    #######
+    private
+    #######
+
+    # Return the port that will be the default if the collector hasn't been
+    # created.
+    def fallback_port
+      30_000 + ($$ % 10_000)
+    end
+
+  end
+end

data/test/new_relic/http_client_test_cases.rb

@@ -0,0 +1,444 @@
+# 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"
+require 'mocha'
+
+module HttpClientTestCases
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation,
+          NewRelic::Agent::CrossAppMonitor::EncodingFunctions,
+          NewRelic::Agent::CrossAppTracing
+
+  TRANSACTION_GUID = 'BEC1BC64675138B9'
+
+  $fake_server = NewRelic::FakeExternalServer.new
+  $fake_secure_server = NewRelic::FakeSecureExternalServer.new
+
+  def setup
+    $fake_server.reset
+    $fake_server.run
+
+    $fake_secure_server.reset
+    $fake_secure_server.run
+
+    NewRelic::Agent.manual_start(
+      :"cross_application_tracer.enabled" => false,
+      :cross_process_id                   => "269975#22824",
+      :encoding_key                       => "gringletoes",
+      :trusted_account_ids                => [269975]
+    )
+
+    NewRelic::Agent.instance.reset_stats
+
+    NewRelic::Agent.instance.events.clear
+    NewRelic::Agent.instance.cross_app_monitor.register_event_listeners
+    NewRelic::Agent.instance.events.notify(:finished_configuring)
+
+    @nr_header = nil
+    NewRelic::Agent.instance.events.subscribe(:after_call) do |_, (_, headers, _)|
+      headers[ NR_APPDATA_HEADER ] = @nr_header unless @nr_header.nil?
+    end
+
+    @engine = NewRelic::Agent.instance.stats_engine
+    NewRelic::Agent::TransactionInfo.get.guid = TRANSACTION_GUID
+  end
+
+  def teardown
+    NewRelic::Agent.instance.transaction_sampler.reset!
+    Thread::current[:newrelic_scope_stack] = nil
+    NewRelic::Agent.instance.stats_engine.end_transaction
+  end
+
+  # Helpers to support shared tests
+
+  def use_ssl
+    @ssl = true
+  end
+
+  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_get
+    res = get_response
+
+    assert_match %r/<head>/i, body(res)
+    assert_metrics_recorded([
+      "External/all",
+      "External/localhost/#{client_name}/GET",
+      "External/allOther",
+      "External/localhost/all"
+    ])
+  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 = get_response_multi(default_url, n)
+
+      responses.each do |res|
+        assert_match %r/<head>/i, body(res)
+      end
+
+      expected = { :call_count => n }
+      assert_metrics_recorded(
+        "External/all" => expected,
+        "External/localhost/#{client_name}/GET" => expected,
+        "External/allOther" => expected,
+        "External/localhost/all" => expected
+      )
+    end
+  end
+
+  def test_background
+    res = nil
+
+    perform_action_with_newrelic_trace("task", :category => :task) do
+      res = get_response
+    end
+
+    assert_match %r/<head>/i, body(res)
+    assert_metrics_recorded([
+      "External/all",
+      "External/allOther",
+      "External/localhost/all",
+      "External/localhost/#{client_name}/GET",
+      ["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("task") do
+      res = get_response
+    end
+
+    assert_match %r/<head>/i, body(res)
+    assert_metrics_recorded([
+      "External/all",
+      "External/localhost/#{client_name}/GET",
+      "External/allWeb",
+      "External/localhost/all",
+      "Controller/#{self.class.name}/task"
+    ])
+
+    assert_metrics_not_recorded([
+      "External/allOther"
+    ])
+  end
+
+
+  def test_transactional_traces_nodes
+    perform_action_with_newrelic_trace("task") do
+      res = get_response
+
+      last_segment = find_last_transaction_segment()
+      assert_equal "External/localhost/#{client_name}/GET", last_segment.metric_name
+    end
+  end
+
+  def test_ignore
+    in_transaction do
+      NewRelic::Agent.disable_all_tracing do
+        res = post_response
+      end
+    end
+
+    assert_metrics_recorded([])
+  end
+
+  def test_head
+    res = head_response
+
+    assert_metrics_recorded([
+      "External/all",
+      "External/localhost/#{client_name}/HEAD",
+      "External/allOther",
+      "External/localhost/all"
+    ])
+  end
+
+  def test_post
+    post_response
+
+    assert_metrics_recorded([
+      "External/all",
+      "External/localhost/#{client_name}/POST",
+      "External/allOther",
+      "External/localhost/all"
+    ])
+  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
+      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
+      get_response
+      assert_equal "VURQV1BZRkZdXUFT", server.requests.last["HTTP_X_NEWRELIC_ID"]
+    end
+  end
+
+  def test_agent_doesnt_add_a_request_header_to_outgoing_requests_if_xp_disabled
+    get_response
+    assert_equal false, server.requests.last.keys.any? {|k| k =~ /NEWRELIC_ID/}
+  end
+
+
+  def test_instrumentation_with_crossapp_enabled_records_normal_metrics_if_no_header_present
+    @nr_header = ""
+
+    with_config(:"cross_application_tracer.enabled" => true) do
+      in_transaction("test") do
+        get_response
+      end
+    end
+
+    assert_metrics_recorded([
+      "External/all",
+      "External/allOther",
+      "External/localhost/all",
+      "External/localhost/#{client_name}/GET",
+      ["External/localhost/#{client_name}/GET", "test"]
+    ])
+  end
+
+  def test_instrumentation_with_crossapp_disabled_records_normal_metrics_even_if_header_is_present
+    @nr_header =
+      make_app_data_payload( "18#1884", "txn-name", 2, 8, 0, TRANSACTION_GUID )
+
+    in_transaction("test") do
+      get_response
+    end
+
+    assert_metrics_recorded([
+      "External/all",
+      "External/allOther",
+      "External/localhost/all",
+      "External/localhost/#{client_name}/GET",
+       ["External/localhost/#{client_name}/GET", "test"]
+    ])
+  end
+
+  def test_instrumentation_with_crossapp_enabled_records_crossapp_metrics_if_header_present
+    @nr_header =
+      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_segment = find_last_transaction_segment()
+        assert_includes last_segment.params.keys, :transaction_guid
+        assert_equal TRANSACTION_GUID, last_segment.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
+    @nr_header =
+      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_segment = find_last_transaction_segment()
+        assert_includes last_segment.params.keys, :transaction_guid
+        assert_equal TRANSACTION_GUID, last_segment.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
+    @nr_header =
+      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_metrics_recorded([
+      "External/all",
+      "External/allOther",
+      "External/localhost/#{client_name}/GET",
+      "External/localhost/all",
+      ["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
+      assert_nothing_raised do
+        res = get_response
+      end
+    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
+      assert_nothing_raised do
+        res = get_response
+      end
+    end
+
+    assert_equal NewRelic::FakeExternalServer::STATUS_MESSAGE, body(res)
+  end
+
+  def test_doesnt_misbehave_when_transaction_tracing_is_disabled
+    @engine.transaction_sampler = nil
+
+    # 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
+      get_response
+    end
+
+    assert_no_match( /undefined method `rename_scope_segment" for nil:NilClass/i,
+                     logger.messages.flatten.map {|log| log.to_s }.join(" ") )
+
+  ensure
+    @engine.transaction_sampler = NewRelic::Agent.agent.transaction_sampler
+  end
+
+  def test_includes_full_url_in_transaction_trace
+    full_url = "#{default_url}?foo=bar#fragment"
+    in_transaction do
+      get_response(full_url)
+      last_segment = find_last_transaction_segment()
+      filtered_uri = default_url
+      assert_equal filtered_uri, last_segment.params[:uri]
+    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'.
+    if client_name == '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 => e
+          # 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_segment = find_last_transaction_segment()
+        assert_equal("External/localhost/#{client_name}/GET", last_segment.metric_name)
+      end
+
+      evil_server.stop
+    end
+  end
+
+  def make_app_data_payload( *args )
+    return obfuscate_with_key( 'gringletoes', args.to_json ).gsub( /\n/, '' ) + "\n"
+  end
+
+end