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/agent/instrumentation/queue_time_test.rb DELETED

@@ -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 DELETED

@@ -1,44 +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
-end
-class NewRelic::Agent::Instrumentation::RackTest < Minitest::Test
-  def generate_minimal_rack_app mock_response
-    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(MinimalRackApp)
-    generator.new(mock_response)
-  end
-  def test_basic_rack_app
-    # should return what we send in, even when instrumented
-    x = generate_minimal_rack_app([200, {}, ["whee"]])
-    assert_equal [200, {}, ["whee"]], x.call({})
-    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp/call'])
-  end
-  def test_basic_rack_app_404
-    x = generate_minimal_rack_app([404, {}, ["whee"]])
-    assert_equal [404, {}, ["whee"]], x.call({})
-    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp/call'])
-  end
-  def test_does_not_double_instrument_middlewares
-    x = generate_minimal_rack_app([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 DELETED

@@ -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 DELETED

@@ -1,62 +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_root_route
-            env = { "newrelic.last_route" => /\A\/\z/}
-            request = stub(:request_method => "GET")
-            result = TransactionNamer.transaction_name_for_route(env, request)
-            assert_equal "GET /", 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 DELETED

@@ -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

data/test/new_relic/agent/instrumentation/task_instrumentation_test.rb DELETED

@@ -1,186 +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::TaskInstrumentationTest < Minitest::Test
-  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-  def run_task_inner(n)
-    return if n == 0
-    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
-    run_task_inner(n-1)
-  end
-  def run_task_outer(n=0)
-    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
-    run_task_inner(n)
-    run_task_inner(n)
-  end
-  def run_task_exception
-    NewRelic::Agent.add_custom_attributes(:custom_one => 'one custom val')
-    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
-    raise "This is an error"
-  end
-  def run_background_job
-    "This is a background job"
-  end
-  add_transaction_tracer :run_task_exception
-  add_transaction_tracer :run_task_inner, :name => 'inner_task_#{args[0]}'
-  add_transaction_tracer :run_task_outer, :name => 'outer_task', :params => '{ :level => args[0] }'
-  add_transaction_tracer :run_background_job, :category => :task
-  def setup
-    @agent = NewRelic::Agent.instance
-    @agent.transaction_sampler.reset!
-    @agent.stats_engine.clear_stats
-  end
-  #
-  # Tests
-  #
-  def test_should_run
-    run_task_inner(0)
-    assert_metrics_recorded_exclusive([
-      'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
-      'Apdex/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
-      'HttpDispatcher',
-      'ApdexAll',
-      'Apdex'
-    ])
-  end
-  def test_should_handle_single_recursive_invocation
-    run_task_inner(1)
-    assert_metrics_recorded_exclusive(
-      [
-        'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
-        'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
-        [
-          'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
-          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0'
-        ],
-        'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
-        [
-          'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
-          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0'
-        ],
-      ],
-      :filter => /^(Sub)?Controller/
-    )
-  end
-  def test_should_handle_recursive_task_invocations
-    run_task_inner(3)
-    assert_metrics_recorded_exclusive(
-      [
-        'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
-        'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
-        [
-          'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
-          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0'
-        ],
-        'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
-        [
-          'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
-          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0'
-        ],
-        'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2',
-        [
-          'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2',
-          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0'
-        ],
-        'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3',
-        [
-          'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3',
-          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0'
-        ],
-      ],
-      :filter => /^(Nested\/)?Controller/
-    )
-  end
-  def test_should_handle_nested_task_invocations
-    run_task_outer(3)
-    assert_metrics_recorded({
-      'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task' => { :call_count => 1 },
-      'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0'  => { :call_count => 1 }
-    })
-  end
-  def test_transaction
-    with_config(:capture_params => true) do
-      run_task_outer(10)
-    end
-    assert_metrics_recorded({
-      'Nested/Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task'   => { :call_count => 1 },
-      'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0' => { :call_count => 1 }
-    })
-    assert_metrics_not_recorded(['Controller'])
-    sample = @agent.transaction_sampler.last_sample
-    refute_nil(sample)
-    cpu_time = attributes_for(sample, :intrinsic)[:cpu_time]
-    refute_nil(cpu_time, "cpu time nil: \n#{sample}")
-    assert(cpu_time >= 0, "cpu time: #{cpu_time},\n#{sample}")
-    assert_equal(10, attributes_for(sample, :agent)['request.parameters.level'])
-  end
-  def test_perform_action_with_newrelic_trace_saves_params
-    account = 'Redrocks'
-    with_config(:capture_params => true) do
-      perform_action_with_newrelic_trace(:name => 'hello', :force => true,
-        :params => { :account => account }) do
-        self.class.inspect
-      end
-    end
-    assert_metrics_recorded(['Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello'])
-    sample = @agent.transaction_sampler.last_sample
-    refute_nil(sample)
-    assert_equal(account, attributes_for(sample, :agent)['request.parameters.account'])
-  end
-  def test_errors_are_noticed_and_not_swallowed
-    @agent.error_collector.expects(:notice_error).once
-    assert_raises(RuntimeError) { run_task_exception }
-  end
-  def test_error_collector_captures_custom_params
-    @agent.error_collector.error_trace_aggregator.harvest!
-    run_task_exception rescue nil
-    errors = @agent.error_collector.error_trace_aggregator.harvest!
-    assert_equal(1, errors.size)
-    error = errors.first
-    assert_equal("Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_task_exception", error.path)
-    refute_nil(error.stack_trace)
-    result = error.attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER)
-    refute_nil(result["custom_one"])
-  end
-  def test_instrument_background_job
-    run_background_job
-    assert_metrics_recorded([
-      'OtherTransaction/Background/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_background_job',
-      'OtherTransaction/Background/all',
-      'OtherTransaction/all'
-    ])
-  end
-end