sundawg_newrelic_rpm 3.5.8.1

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

@@ -0,0 +1,66 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+module NewRelic::Agent::Instrumentation
+  class BrowserMonitoringTimingsTest < Test::Unit::TestCase
+
+    def setup
+      Time.stubs(:now).returns(Time.at(2000))
+      @transaction = stub(
+        :transaction_name => "Name",
+        :start_time => 0
+      )
+    end
+
+    def test_queue_time_in_millis
+      t = BrowserMonitoringTimings.new(1000.1234, @transaction)
+      assert_equal 1_000_123, t.queue_time_in_millis
+    end
+
+    def test_queue_time_in_seconds
+      t = BrowserMonitoringTimings.new(1000.1234, @transaction)
+      assert_equal 1_000.1234, t.queue_time_in_seconds
+    end
+
+    def test_queue_time_clamps_to_positive
+      t = BrowserMonitoringTimings.new(-1000, @transaction)
+      assert_equal 0, t.queue_time_in_millis
+    end
+
+    def test_queue_time_clamps_to_positive_in_seconds
+      t = BrowserMonitoringTimings.new(-1000, @transaction)
+      assert_equal 0, t.queue_time_in_seconds
+    end
+
+    def test_app_time_in_millis
+      t = BrowserMonitoringTimings.new(nil, @transaction)
+      assert_equal 2_000_000, t.app_time_in_millis
+    end
+
+    def test_app_time_in_seconds
+      t = BrowserMonitoringTimings.new(nil, @transaction)
+      assert_equal 2_000, t.app_time_in_seconds
+    end
+
+    def test_locks_time_at_instantiation
+      t = BrowserMonitoringTimings.new(1000, @transaction)
+      original = t.app_time_in_seconds
+
+      Time.stubs(:now).returns(Time.at(3000))
+      later = t.app_time_in_seconds
+
+      assert_equal original, later
+    end
+
+    def test_transaction_name
+      t = BrowserMonitoringTimings.new(nil, @transaction)
+      assert_equal "Name", t.transaction_name
+    end
+
+    def test_defaults_to_transaction_info
+      t = BrowserMonitoringTimings.new(1000, nil)
+      assert_equal nil, t.transaction_name
+      assert_equal 0.0, t.start_time_in_millis
+    end
+
+  end
+end

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

@@ -0,0 +1,107 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Test::Unit::TestCase
+  require 'new_relic/agent/instrumentation/controller_instrumentation'
+  class TestObject
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  end
+
+  def setup
+    @object = TestObject.new
+  end
+
+  def test_detect_upstream_wait_basic
+    start_time = Time.now
+    # should return the start time above by default
+    @object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
+    NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
+      .with({:request => 'headers'}, start_time).returns(start_time)
+    assert_equal(start_time, @object.send(:_detect_upstream_wait, start_time))
+  end
+
+  def test_detect_upstream_wait_with_upstream
+    start_time = Time.now
+    runs_at = start_time + 1
+    @object = TestObject.new
+    @object.expects(:newrelic_request_headers).returns(true).twice
+    NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
+      .with(true, runs_at).returns(start_time)
+    assert_equal(start_time, @object.send(:_detect_upstream_wait, runs_at))
+  end
+
+  def test_detect_upstream_wait_swallows_errors
+    start_time = Time.now
+    # should return the start time above when an error is raised
+    @object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
+    NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
+      .with({:request => 'headers'}, start_time).raises("an error")
+    assert_equal(start_time, @object.send(:_detect_upstream_wait, start_time))
+  end
+
+  def test_transaction_name_calls_newrelic_metric_path
+    @object.stubs(:newrelic_metric_path).returns('some/wacky/path')
+    assert_equal('Controller/some/wacky/path', @object.send(:transaction_name))
+  end
+
+  def test_transaction_name_applies_category_and_path
+    assert_equal('Controller/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :controller,
+                              :path => 'metric/path'))
+    assert_equal('OtherTransaction/Background/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :task, :path => 'metric/path'))
+    assert_equal('Controller/Rack/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :rack, :path => 'metric/path'))
+    assert_equal('Controller/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :uri, :path => 'metric/path'))
+    assert_equal('Controller/Sinatra/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :sinatra,
+                              :path => 'metric/path'))
+    assert_equal('Blarg/metric/path',
+                 @object.send(:transaction_name,
+                              :category => 'Blarg', :path => 'metric/path'))
+
+  end
+
+  def test_transaction_name_uses_class_name_if_path_not_specified
+    assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject',
+                 @object.send(:transaction_name, :category => :controller))
+  end
+
+  def test_transaction_name_applies_action_name_if_specified_and_not_path
+    assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/action',
+                 @object.send(:transaction_name, :category => :controller,
+                              :name => 'action'))
+  end
+
+  def test_transaction_name_applies_name_rules
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                  'replacement'      => '*',
+                                                  'replace_all'      => true)
+    NewRelic::Agent.instance.transaction_rules << rule
+    assert_equal('foo/*/bar/*',
+                 @object.send(:transaction_name, :category => 'foo',
+                              :path => '1/bar/22'))
+  ensure
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
+                                              NewRelic::Agent::RulesEngine.new)
+  end
+
+  def test_path_class_and_action
+    result = @object.send(:path_class_and_action, {})
+    assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject", result)
+  end
+
+  def test_path_class_and_action_with_name
+    result = @object.send(:path_class_and_action, :name => "test")
+    assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/test", result)
+  end
+
+  def test_path_class_and_action_with_overridden_class_name
+    result = @object.send(:path_class_and_action, :name => "perform", :class_name => 'Resque')
+    assert_equal("Resque/perform", result)
+  end
+end

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

@@ -0,0 +1,11 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+class NewRelic::Agent::Instrumentation::InstrumentationTest < Test::Unit::TestCase
+  def test_load_all_instrumentation_files
+    # just checking for syntax errors and unguarded code
+    Dir.glob('new_relic/agent/instrumentation/**/*.rb') do |f|
+      require f
+    end
+    require 'new_relic/delayed_job_injection'
+  end
+end
+

data/test/new_relic/agent/instrumentation/metric_frame/pop_test.rb

@@ -0,0 +1,171 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'test_helper'))
+require 'new_relic/agent/instrumentation/metric_frame/pop'
+class NewRelic::Agent::Instrumentation::MetricFrame::PopTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::MetricFrame::Pop
+
+  attr_reader :agent
+  attr_reader :transaction_sampler
+  attr_reader :sql_sampler
+
+  def setup
+    @agent = mock('agent')
+    @transaction_sampler = mock('transaction sampler')
+    @sql_sampler = mock('sql sampler')
+  end
+
+  def teardown
+    Thread.current[:newrelic_metric_frame] = nil
+  end
+
+  def test_clear_thread_metric_frame
+    Thread.current[:newrelic_metric_frame] = 'whee'
+    clear_thread_metric_frame!
+    assert_equal nil, Thread.current[:newrelic_metric_frame], 'should nil out the thread var'
+  end
+
+  def test_set_new_scope
+    fakeagent = mock('agent')
+    self.expects(:agent).returns(fakeagent)
+    fakeengine = mock('stats_engine')
+    fakeagent.expects(:stats_engine).returns(fakeengine)
+    fakeengine.expects(:scope_name=).with('A METRIC')
+
+    set_new_scope!('A METRIC')
+  end
+
+  def test_log_underflow
+    expects_logging(:error, regexp_matches(/Underflow in metric frames: /))
+    log_underflow
+  end
+
+  def test_notice_scope_empty
+    transaction_sampler.expects(:notice_scope_empty)
+    sql_sampler.expects(:notice_scope_empty)
+    notice_scope_empty
+  end
+
+  def test_record_transaction_cpu_positive
+    self.expects(:cpu_burn).once.returns(1.0)
+    transaction_sampler.expects(:notice_transaction_cpu_time).with(1.0)
+    record_transaction_cpu
+  end
+
+  def test_record_transaction_cpu_negative
+    self.expects(:cpu_burn).once.returns(nil)
+    # should not be called for the nil case
+    transaction_sampler.expects(:notice_transaction_cpu_time).never
+    record_transaction_cpu
+  end
+
+  def test_normal_cpu_burn_positive
+    @process_cpu_start = 3
+    self.expects(:process_cpu).returns(4)
+    assert_equal 1, normal_cpu_burn
+  end
+
+  def test_normal_cpu_burn_negative
+    @process_cpu_start = nil
+    self.expects(:process_cpu).never
+    assert_equal nil, normal_cpu_burn
+  end
+
+  def test_jruby_cpu_burn_positive
+    @jruby_cpu_start = 3
+    self.expects(:jruby_cpu_time).returns(4)
+    self.expects(:record_jruby_cpu_burn).with(1)
+    assert_equal 1, jruby_cpu_burn
+  end
+
+  def test_jruby_cpu_burn_negative
+    @jruby_cpu_start = nil
+    self.expects(:jruby_cpu_time).never
+    self.expects(:record_jruby_cpu_burn).never
+    assert_equal nil, jruby_cpu_burn
+  end
+
+  def test_record_jruby_cpu_burn
+    NewRelic::Agent.get_stats_no_scope(NewRelic::Metrics::USER_TIME).expects(:record_data_point).with(1.0)
+    record_jruby_cpu_burn(1.0)
+  end
+
+  def test_cpu_burn_normal
+    self.expects(:normal_cpu_burn).returns(1)
+    self.expects(:jruby_cpu_burn).never
+    assert_equal 1, cpu_burn
+  end
+
+  def test_cpu_burn_jruby
+    self.expects(:normal_cpu_burn).returns(nil)
+    self.expects(:jruby_cpu_burn).returns(2)
+    assert_equal 2, cpu_burn
+  end
+
+  def test_end_transaction
+    fake_stats_engine = mock('stats engine')
+    agent.expects(:stats_engine).returns(fake_stats_engine)
+    fake_stats_engine.expects(:end_transaction)
+    end_transaction!
+  end
+
+  def test_notify_transaction_sampler_true
+    self.expects(:record_transaction_cpu)
+    self.expects(:notice_scope_empty)
+    notify_transaction_sampler(true)
+  end
+
+  def test_notify_transaction_sampler_false
+    self.expects(:record_transaction_cpu)
+    self.expects(:notice_scope_empty)
+    notify_transaction_sampler(false)
+  end
+
+  def test_traced
+    NewRelic::Agent.expects(:is_execution_traced?)
+    traced?
+  end
+
+  def test_handle_empty_path_stack_default
+    @path_stack = [] # it is empty
+    self.expects(:traced?).returns(true)
+    fakemetric = mock('metric')
+    fakemetric.expects(:is_web_transaction?).returns(true)
+    self.expects(:notify_transaction_sampler).with(true)
+    self.expects(:end_transaction!)
+    self.expects(:clear_thread_metric_frame!)
+    handle_empty_path_stack(fakemetric)
+  end
+
+  def test_handle_empty_path_stack_non_web
+    @path_stack = [] # it is empty
+    self.expects(:traced?).returns(true)
+    fakemetric = mock('metric')
+    fakemetric.expects(:is_web_transaction?).returns(false)
+    self.expects(:notify_transaction_sampler).with(false)
+    self.expects(:end_transaction!)
+    self.expects(:clear_thread_metric_frame!)
+    handle_empty_path_stack(fakemetric)
+  end
+
+  def test_handle_empty_path_stack_error
+    @path_stack = ['not empty']
+    assert_raise(RuntimeError) do
+      handle_empty_path_stack(mock('metric'))
+    end
+  end
+
+  def test_handle_empty_path_stack_untraced
+    @path_stack = [] # it is empty
+    self.expects(:traced?).returns(false)
+    fakemetric = mock('metric')
+    fakemetric.expects(:is_web_transaction?).never
+    self.expects(:end_transaction!)
+    self.expects(:clear_thread_metric_frame!)
+    handle_empty_path_stack(fakemetric)
+  end
+
+  def test_current_stack_metric
+    self.expects(:metric_name)
+    current_stack_metric
+  end
+end
+

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

@@ -0,0 +1,151 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
+
+  attr_reader :f
+  def setup
+    @f = NewRelic::Agent::Instrumentation::MetricFrame.new
+  end
+
+  def test_request_parsing__none
+    assert_nil f.uri
+    assert_nil f.referer
+  end
+  def test_request_parsing__path
+    request = stub(:path => '/path?hello=bob#none')
+    f.request = request
+    assert_equal "/path", f.uri
+  end
+  def test_request_parsing__fullpath
+    request = stub(:fullpath => '/path?hello=bob#none')
+    f.request = request
+    assert_equal "/path", f.uri
+  end
+  def test_request_parsing__referer
+    request = stub(:referer => 'https://www.yahoo.com:8080/path/hello?bob=none&foo=bar')
+    f.request = request
+    assert_nil f.uri
+    assert_equal "https://www.yahoo.com:8080/path/hello", f.referer
+  end
+
+  def test_request_parsing__uri
+    request = stub(:uri => 'http://creature.com/path?hello=bob#none', :referer => '/path/hello?bob=none&foo=bar')
+    f.request = request
+    assert_equal "/path", f.uri
+    assert_equal "/path/hello", f.referer
+  end
+
+  def test_request_parsing__hostname_only
+    request = stub(:uri => 'http://creature.com')
+    f.request = request
+    assert_equal "/", f.uri
+    assert_nil f.referer
+  end
+  def test_request_parsing__slash
+    request = stub(:uri => 'http://creature.com/')
+    f.request = request
+    assert_equal "/", f.uri
+    assert_nil f.referer
+  end
+
+  def test_queue_time
+    f.apdex_start = 1000
+    f.start = 1500
+    assert_equal 500, f.queue_time
+  end
+
+  def test_update_apdex_records_failed_when_specified
+    stats = NewRelic::Agent::Stats.new
+    NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.1, true)
+    assert_equal 0, stats.apdex_s
+    assert_equal 0, stats.apdex_t
+    assert_equal 1, stats.apdex_f
+  end
+
+  def test_update_apdex_records_satisfying
+    stats = NewRelic::Agent::Stats.new
+    with_config(:apdex_t => 1) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.5, false)
+    end
+    assert_equal 1, stats.apdex_s
+    assert_equal 0, stats.apdex_t
+    assert_equal 0, stats.apdex_f
+  end
+
+  def test_update_apdex_records_tolerating
+    stats = NewRelic::Agent::Stats.new
+    with_config(:apdex_t => 1) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 1.5, false)
+    end
+    assert_equal 0, stats.apdex_s
+    assert_equal 1, stats.apdex_t
+    assert_equal 0, stats.apdex_f
+  end
+
+  def test_update_apdex_records_failing
+    stats = NewRelic::Agent::Stats.new
+    with_config(:apdex_t => 1) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 4.5, false)
+    end
+    assert_equal 0, stats.apdex_s
+    assert_equal 0, stats.apdex_t
+    assert_equal 1, stats.apdex_f
+  end
+
+  def test_update_apdex_records_correct_apdex_for_key_transaction
+    txn_info = NewRelic::Agent::TransactionInfo.get
+    stats = NewRelic::Agent::Stats.new
+    config = {
+      :web_transactions_apdex => {
+        'Controller/slow/txn' => 4,
+        'Controller/fast/txn' => 0.1,
+      },
+      :apdex => 1
+    }
+
+    txn_info.transaction_name = 'Controller/slow/txn'
+    with_config(config, :do_not_cast => true) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 3.5, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 5.5, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 16.5, false)
+    end
+    assert_equal 1, stats.apdex_s
+    assert_equal 1, stats.apdex_t
+    assert_equal 1, stats.apdex_f
+
+    txn_info.transaction_name = 'Controller/fast/txn'
+    with_config(config, :do_not_cast => true) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.05, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.2, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.5, false)
+    end
+    assert_equal 2, stats.apdex_s
+    assert_equal 2, stats.apdex_t
+    assert_equal 2, stats.apdex_f
+
+    txn_info.transaction_name = 'Controller/other/txn'
+    with_config(config, :do_not_cast => true) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.5, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 2, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 5, false)
+    end
+    assert_equal 3, stats.apdex_s
+    assert_equal 3, stats.apdex_t
+    assert_equal 3, stats.apdex_f
+  end
+
+  def test_record_apdex_stores_apdex_t_in_min_and_max
+    stats_engine = NewRelic::Agent.instance.stats_engine
+    stats_engine.reset_stats
+    metric = stub(:apdex_metric_path => 'Apdex/Controller/some/txn')
+    NewRelic::Agent.instance.instance_variable_set(:@stats_engine, stats_engine)
+
+    with_config(:apdex_t => 2.5) do
+      NewRelic::Agent::Instrumentation::MetricFrame.record_apdex(metric, 1, 1, false)
+    end
+    assert_equal 2.5, stats_engine.lookup_stats('Apdex').min_call_time
+    assert_equal 2.5, stats_engine.lookup_stats('Apdex').max_call_time
+    assert_equal 2.5, stats_engine.lookup_stats('Apdex/Controller/some/txn').min_call_time
+    assert_equal 2.5, stats_engine.lookup_stats('Apdex/Controller/some/txn').max_call_time
+  end
+end