newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -1,257 +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'))
-
-class NewRelic::Agent::Instrumentation::MiddlewareProxyTest < Minitest::Test
-
-  def setup
-    NewRelic::Agent.drop_buffered_data
-  end
-
-  def test_generator_creates_wrapped_instances
-    middleware_class = Class.new
-
-    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
-    wrapped_instance  = generator.new
-
-    assert_kind_of(NewRelic::Agent::Instrumentation::MiddlewareProxy, wrapped_instance)
-    assert_kind_of(middleware_class, wrapped_instance.target)
-  end
-
-  def test_generator_passes_through_initialize_args
-    middleware_class = Class.new do
-      attr_reader :initialize_args
-
-      def initialize(*args)
-        @initialize_args = args
-      end
-    end
-
-    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
-    wrapped_instance = generator.new('abc', 123)
-
-    assert_equal(['abc', 123], wrapped_instance.target.initialize_args)
-  end
-
-  def test_generator_passes_through_block_to_initialize
-    middleware_class = Class.new do
-      attr_reader :initialize_args
-
-      def initialize(*args, &blk)
-        @initialize_args = args
-        blk.call
-      end
-    end
-
-    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
-
-    block_called = false
-    wrapped_instance = generator.new('abc', 123) do
-      block_called = true
-    end
-
-    assert block_called
-    assert_equal(['abc', 123], wrapped_instance.target.initialize_args)
-  end
-
-  def test_anonymous_class_naming
-    middleware_class = Class.new
-    wrapped_instance = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(middleware_class.new)
-
-    name = wrapped_instance.transaction_options[:transaction_name]
-    assert_equal("Middleware/Rack/AnonymousClass/call", name)
-  end
-
-  class BaseForAnonymous
-  end
-
-  def test_anonymous_derived_class_naming
-    middleware_class = Class.new(BaseForAnonymous)
-    wrapped_instance = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(middleware_class.new)
-
-    name = wrapped_instance.transaction_options[:transaction_name]
-    assert_equal("Middleware/Rack/#{BaseForAnonymous.name}/call", name)
-  end
-
-  def test_does_not_wrap_sinatra_apps
-    sinatra_dummy_module = Module.new
-    sinatra_dummy_class  = Class.new(Object)
-    app_class            = Class.new(sinatra_dummy_class)
-
-    with_constant_defined(:'::Sinatra', sinatra_dummy_module) do
-      with_constant_defined(:'::Sinatra::Base', sinatra_dummy_class) do
-        app = app_class.new
-
-        wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-
-        assert_same(app, wrapped)
-      end
-    end
-  end
-
-  def test_does_not_wrap_instrumented_middlewares
-    app_class = Class.new do
-      def _nr_has_middleware_tracing
-        true
-      end
-    end
-
-    app = app_class.new
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-
-    assert_same(app, wrapped)
-  end
-
-  def test_should_wrap_non_instrumented_middlewares
-    app_class = Class.new do
-      def call(env)
-        :yay
-      end
-    end
-
-    app = app_class.new
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-
-    assert_kind_of(NewRelic::Agent::Instrumentation::MiddlewareProxy, wrapped)
-  end
-
-  def test_call_should_proxy_to_target_when_in_transaction
-    call_was_called = false
-    call_received   = nil
-
-    app = lambda do |env|
-      call_was_called = true
-      call_received   = env
-      :super_duper
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-    env = {}
-
-    ret = nil
-    in_transaction do
-      ret = wrapped.call(env)
-    end
-
-    assert(call_was_called)
-    assert_equal(:super_duper, ret)
-    assert_same(env, call_received)
-  end
-
-  def test_call_should_proxy_to_target_when_not_in_transaction
-    call_was_called = false
-    call_received   = nil
-
-    app = lambda do |env|
-      call_was_called = true
-      call_received   = env
-      :super_duper
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-    env = {}
-    ret = wrapped.call(env)
-
-    assert(call_was_called)
-    assert_equal(:super_duper, ret)
-    assert_same(env, call_received)
-  end
-
-  def test_should_start_transaction_if_none_is_running
-    app = lambda do |env|
-      :super_duper
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-
-    wrapped.call({})
-
-    assert_metrics_recorded("HttpDispatcher")
-  end
-
-  def test_should_respect_force_transaction_flag
-    app = lambda do |env|
-      :super_duper
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-
-    in_transaction('Controller/foo', :category => :controller) do
-      wrapped.call({})
-    end
-
-    assert_metrics_recorded('Controller/Rack/Proc/call')
-  end
-
-  def test_should_get_the_right_name_when_target_is_a_class
-    target_class = Class.new do
-      def self.name
-        "GreatClass"
-      end
-
-      def self.call(env)
-        :super_duper
-      end
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(target_class, true)
-
-    wrapped.call({})
-
-    assert_metrics_recorded('Controller/Rack/GreatClass/call')
-  end
-
-  def test_should_emit_events_once
-    app = Proc.new { |env| [200, {}, ["nothing"]]}
-    middleware = Proc.new { |env| app.call(env) }
-    wrapped_app = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-    wrapped_middleware = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(middleware, true)
-
-    before_call_count = 0
-    after_call_count = 0
-
-    NewRelic::Agent.instance.events.subscribe(:before_call) { before_call_count += 1 }
-    NewRelic::Agent.instance.events.subscribe(:after_call) { after_call_count += 1 }
-
-    result = wrapped_middleware.call({})
-    assert_equal 1, before_call_count
-    assert_equal 1, after_call_count
-  end
-
-  def test_before_call_should_receive_rack_env_hash
-    app = Proc.new { |env| [200, {}, ["nothing"]]}
-    wrapped_app = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-
-    original_env = {}
-    env_from_before_call = nil
-
-    NewRelic::Agent.instance.events.subscribe(:before_call) { |env| env_from_before_call = env }
-
-    wrapped_app.call(original_env)
-    assert_same original_env, env_from_before_call
-  end
-
-  def test_before_call_should_receive_rack_env_hash
-    app = Proc.new { |env| [200, {}, ["nothing"]] }
-    wrapped_app = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-
-    original_env = {}
-    env_from_after_call = nil
-    result_from_after_call = nil
-
-    NewRelic::Agent.instance.events.subscribe(:after_call) do |env, result|
-      env_from_after_call = env
-      result_from_after_call = result
-    end
-
-    result = wrapped_app.call(original_env)
-
-    assert_same original_env, env_from_after_call
-    assert_same result, result_from_after_call
-  end
-end
-

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

@@ -1,49 +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'))
-require 'new_relic/agent/instrumentation/middleware_tracing'
-
-class NewRelic::Agent::Instrumentation::MiddlewareTracingTest < Minitest::Test
-  class UserError < StandardError
-  end
-
-  class HostClass
-    include NewRelic::Agent::Instrumentation::MiddlewareTracing
-
-    attr_reader :category
-
-    def initialize(&blk)
-      @action = blk
-    end
-
-    def target
-      self
-    end
-
-    def transaction_options
-      {}
-    end
-
-    def traced_call(env)
-      @action.call
-    end
-  end
-
-  def test_dont_block_errors_during_malfunctioning_transaction
-    NewRelic::Agent::Transaction.stubs(:start).returns(nil)
-
-    middleware = HostClass.new { raise UserError }
-    assert_raises(UserError) do
-      middleware.call({})
-    end
-  end
-
-  def test_dont_raise_when_transaction_start_fails
-    NewRelic::Agent::Transaction.stubs(:start).returns(nil)
-
-    middleware = HostClass.new { [200, {}, ['hi!']] }
-    middleware.call({})
-  end
-end

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

@@ -1,35 +0,0 @@
-#!/usr/bin/env ruby
-# 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 'net/http'
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-require 'new_relic/agent/cross_app_tracing'
-
-class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Minitest::Test
-  def setup
-    NewRelic::Agent.manual_start(
-      :"cross_application_tracer.enabled" => false,
-      :"transaction_tracer.enabled"       => true,
-      :cross_process_id                   => '269975#22824',
-      :encoding_key                       => 'gringletoes'
-    )
-
-    @socket = fixture_tcp_socket( @response )
-
-    NewRelic::Agent.instance.stats_engine.clear_stats
-  end
-
-  def test_scope_stack_integrity_maintained_on_request_failure
-    @socket.stubs(:write).raises('fake network error')
-    with_config(:"cross_application_tracer.enabled" => true) do
-      state    = NewRelic::Agent::TransactionState.tl_get
-      stack    = state.traced_method_stack
-      expected = stack.push_frame(state, 'dummy')
-      Net::HTTP.get(URI.parse('http://www.google.com/index.html')) rescue nil
-      stack.pop_frame(state, expected, 42, Time.now.to_f)
-    end
-  end
-
-end

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

@@ -1,103 +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'))
-class NewRelic::Agent::Instrumentation::QueueTimeTest < Minitest::Test
-  include NewRelic::Agent::Instrumentation
-
-  def setup
-    freeze_time
-  end
-
-  def teardown
-    NewRelic::Agent.drop_buffered_data
-  end
-
-  def test_parse_frontend_timestamp_given_queue_start_header
-    header = { 'HTTP_X_QUEUE_START' => format_header_time(Time.now - 60) }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
-  end
-
-  def test_parse_frontend_timestamp_given_request_start_header
-    header = { 'HTTP_X_REQUEST_START' => format_header_time(Time.now - 60) }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
-  end
-
-  def test_parse_frontend_timestamp_given_middleware_start_header
-    header = { 'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 60) }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
-  end
-
-  def test_parse_frontend_timestamp_from_earliest_header
-    headers = { 'HTTP_X_REQUEST_START'    => format_header_time(Time.now - 63),
-                'HTTP_X_QUEUE_START'      => format_header_time(Time.now - 62),
-                'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 61)}
-
-    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.001)
-  end
-
-  def test_parse_frontend_timestamp_from_earliest_header_out_of_order
-    headers = { 'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 63),
-                'HTTP_X_REQUEST_START'    => format_header_time(Time.now - 62),
-                'HTTP_X_QUEUE_START'      => format_header_time(Time.now - 61) }
-
-    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.001)
-  end
-
-  def test_parse_frontend_timestamp_from_header_in_seconds
-    header = { 'HTTP_X_QUEUE_START' => "t=#{Time.now.to_f - 60}" }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
-  end
-
-  def test_parse_frontend_timestamp_from_header_in_milliseconds
-    header = { 'HTTP_X_QUEUE_START' => "t=#{(Time.now.to_f - 60) * 1_000}" }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
-  end
-
-  def test_parse_frontend_timestamp_from_header_with_multiple_servers
-    now = Time.now.to_f
-    header = { 'HTTP_X_QUEUE_START' => "servera t=#{now - 60}, serverb t=#{now - 30}" }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
-  end
-
-  def test_parse_frontend_timestamp_from_header_missing_t_equals
-    header = { 'HTTP_X_REQUEST_START' => (Time.now.to_f - 60).to_s }
-    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
-  end
-
-  def test_parse_frontend_timestamp_from_header_negative
-    now = Time.now
-    the_future = Time.at(now.to_f + 60)
-    header = { 'HTTP_X_REQUEST_START' => the_future.to_f.to_s }
-    assert_in_delta(now, QueueTime.parse_frontend_timestamp(header, now), 0.001)
-  end
-
-  def test_parsing_malformed_header
-    header = { 'HTTP_X_REQUEST_START' => 'gobledy gook' }
-
-    assert_nil QueueTime.parse_frontend_timestamp(header)
-  end
-
-  def test_parse_timestamp_can_identify_unit
-    now = Time.now.to_f
-    assert_in_delta(now, QueueTime.parse_timestamp(now.to_f.to_s).to_f, 0.001)
-    assert_in_delta(now, QueueTime.parse_timestamp((now.to_f * 1_000).to_s).to_f, 0.001)
-    assert_in_delta(now, QueueTime.parse_timestamp((now.to_f * 1_000_000).to_s).to_f, 0.001)
-  end
-
-  def format_header_time(time=Time.now)
-    "t=#{(time.to_f * 1_000_000).to_i}"
-  end
-
-  def seconds_ago(seconds)
-    Time.at(Time.now.to_f - seconds)
-  end
-
-  def assert_metric_value_in_delta(expected, metric_name, delta)
-    stats_engine = NewRelic::Agent.instance.stats_engine
-    stats_engine.clear_stats
-    yield
-    assert_in_delta(expected, stats_engine.get_stats(metric_name).total_call_time, delta)
-  end
-end

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

@@ -1,47 +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'))
-require 'new_relic/agent/instrumentation/rack'
-
-class MinimalRackApp
-  def initialize(return_value)
-    @return_value = return_value
-  end
-
-  def call(env)
-    @return_value
-  end
-
-  include NewRelic::Agent::Instrumentation::Rack
-end
-
-class NewRelic::Agent::Instrumentation::RackTest < Minitest::Test
-  def test_basic_rack_app
-    # should return what we send in, even when instrumented
-    x = MinimalRackApp.new([200, {}, ["whee"]])
-    assert_equal [200, {}, ["whee"]], x.call({})
-    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
-  end
-
-  def test_basic_rack_app_404
-    x = MinimalRackApp.new([404, {}, ["whee"]])
-    assert_equal [404, {}, ["whee"]], x.call({})
-    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
-  end
-
-  def test_basic_rack_app_ignores_404
-    NewRelic::Agent::Transaction.expects(:abort_transaction!)
-    x = MinimalRackApp.new([404, {}, ["whee"]])
-    assert_equal [404, {}, ["whee"]], x.call({})
-    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
-  end
-
-  def test_does_not_double_instrument_middlewares
-    x = MinimalRackApp.new([200, {}, ["whee"]])
-    wrapped_x = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(x)
-
-    assert_same(x, wrapped_x)
-  end
-end

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

@@ -1,36 +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'))
-require 'new_relic/agent/instrumentation/sequel_helper'
-
-module NewRelic
-  module Agent
-    class SequelHelperTest < Minitest::Test
-      def test_product_name_from_adapter
-        expected_default = "Sequel"
-        default = Hash.new(expected_default)
-
-        adapter_to_name = {
-          :ibmdb => "IBMDB2",
-          :firebird => "Firebird",
-          :informix => "Informix",
-          :jdbc => "JDBC",
-          :mysql => "MySQL",
-          :mysql2 => "MySQL",
-          :oracle => "Oracle",
-          :postgres => "Postgres",
-          :sqlite => "SQLite"
-        }
-
-        default.merge(adapter_to_name).each do |adapter, name|
-          assert_equal name, NewRelic::Agent::Instrumentation::SequelHelper.product_name_from_adapter(adapter)
-        end
-
-        default_result = NewRelic::Agent::Instrumentation::SequelHelper.product_name_from_adapter("YouDontKnowThisAdapter")
-        assert_equal expected_default, default_result
-      end
-    end
-  end
-end

data/test/new_relic/agent/instrumentation/sinatra/transaction_namer_test.rb

@@ -1,55 +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'))
-require 'new_relic/agent/instrumentation/sinatra/transaction_namer'
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Sinatra
-
-        class TransactionNamerTest < Minitest::Test
-
-          def test_transaction_name_for_route
-            env = { "newrelic.last_route" => /^\/the_route$/}
-            request = stub(:request_method => "GET")
-            result = TransactionNamer.transaction_name_for_route(env, request)
-            assert_equal "GET the_route", result
-          end
-
-          def test_transaction_name_for_route_padrino
-            env = {}
-            route = stub(:original_path => "/path/:id")
-            request = stub(:route_obj => route, :request_method => "GET")
-            result = TransactionNamer.transaction_name_for_route(env, request)
-
-            assert_equal "GET path/:id", result
-          end
-
-          def test_transaction_name_for_route_without_routes
-            assert_nil TransactionNamer.transaction_name_for_route({}, nil)
-          end
-
-          def test_basic_sinatra_naming
-            assert_transaction_name "(unknown)", "(unknown)"
-
-            # Sinatra < 1.4 style regexes
-            assert_transaction_name "will_boom", "^/will_boom$"
-            assert_transaction_name "hello/([^/?#]+)", "^/hello/([^/?#]+)$"
-
-            # Sinatra 1.4 style regexs
-            assert_transaction_name "will_boom", "\A/will_boom\z"
-            assert_transaction_name "hello/([^/?#]+)", "\A/hello/([^/?#]+)\z"
-          end
-
-          def assert_transaction_name(expected, original)
-            assert_equal expected, TransactionNamer.transaction_name(original, nil)
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +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'))
-require 'new_relic/agent/instrumentation/sinatra'
-
-class NewRelic::Agent::Instrumentation::SinatraTest < Minitest::Test
-
-  # This fake app is not an actual Sinatra app to avoid having our unit tests
-  # take a dependency directly on it. If you need actual Sinatra classes, go
-  # write the test in the multiver suite.
-  class SinatraTestApp
-    include NewRelic::Agent::Instrumentation::Sinatra
-
-    attr_accessor :env, :request
-
-    def initialize
-      @env = {}
-    end
-  end
-
-  def setup
-    @app = SinatraTestApp.new
-  end
-
-  def test_newrelic_request_headers
-    expected_headers = {:fake => :header}
-    @app.request = mock('request', :env => expected_headers)
-
-    state = NewRelic::Agent::TransactionState.tl_get
-
-    assert_equal(@app.newrelic_request_headers(state), expected_headers)
-  end
-
-  def test_process_route_with_bad_arguments
-    @app.stubs(:env).raises("Boo")
-    @app.expects(:process_route_without_newrelic).once
-    @app.process_route_with_newrelic
-  end
-
-  def test_route_eval_with_bad_params
-    @app.stubs(:env).raises("Boo")
-    @app.expects(:route_eval_without_newrelic).once
-    @app.route_eval_with_newrelic
-  end
-
-  def test_route_eval_without_last_route_doesnt_set_transaction_name
-    @app.stubs(:env).returns({})
-    @app.expects(:route_eval_without_newrelic).once
-    NewRelic::Agent.expects(:set_transaction_name).never
-    @app.route_eval_with_newrelic
-  end
-
-  def test_injects_middleware
-    SinatraTestApp.stubs(:middleware).returns([])
-
-    SinatraTestApp.expects(:build_without_newrelic).once
-    SinatraTestApp.expects(:use).at_least(2)
-
-    SinatraTestApp.build_with_newrelic(@app)
-  end
-
-  def test_doesnt_inject_already_existing_middleware
-    default_middlewares = SinatraTestApp.newrelic_middlewares
-    # mock up the return value of Sinatra's #middleware method, which returns an
-    # Array of Arrays.
-    middleware_info = default_middlewares.map { |m| [m] }
-    SinatraTestApp.stubs(:middleware).returns(middleware_info)
-
-    SinatraTestApp.expects(:build_without_newrelic).once
-    SinatraTestApp.expects(:use).never
-
-    SinatraTestApp.build_with_newrelic(@app)
-  end
-
-  def assert_transaction_name(expected, original)
-    assert_equal expected, NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name(original, nil)
-  end
-end