newrelic_rpm 3.10.0.279 → 3.11.0.283

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -55,7 +55,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
         service.metric_data(new_engine.harvest!)
       end
 
-      assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
+      assert_metrics_recorded(metric => { :total_call_time => 3.0 })
       engine.reset!
     end
 

data/test/new_relic/agent/threading/backtrace_service_test.rb

@@ -34,6 +34,15 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
         assert @service.running?
       end
 
+      def test_doesnt_start_on_resque
+        with_config(:dispatcher => :resque) do
+          fake_worker_loop(@service)
+
+          @service.subscribe(BacktraceService::ALL_TRANSACTIONS)
+          refute @service.running?
+        end
+      end
+
       def test_stops_when_subscription_is_removed
         fake_worker_loop(@service)
 
@@ -325,6 +334,21 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
         fake_transaction_finished('foo', (t0 + 1).to_f, 2.0, thread)
       end
 
+      def test_on_transaction_finished_delivers_background_backtraces
+        fake_worker_loop(@service)
+
+        thread0 = fake_thread(:background)
+
+        profile = @service.subscribe('foo')
+
+        t0 = Time.now
+        @service.poll
+
+        profile.expects(:aggregate).with(thread0.backtrace, :background, thread0).once
+
+        fake_transaction_finished('foo', t0.to_f, 1, thread0, :background)
+      end
+
       def test_does_not_deliver_non_request_backtraces_to_subscribed_profiles
         fake_worker_loop(@service)
 
@@ -351,7 +375,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
         @service.poll
 
         profile.expects(:aggregate).once
-        fake_transaction_finished('foo', t0.to_f, 1.0)
+        fake_transaction_finished('foo', t0.to_f, 1.0, Thread.current)
       end
 
       def test_service_increments_profile_poll_counts
@@ -471,11 +495,12 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
         end
       end
 
-      def fake_transaction_finished(name, start_timestamp, duration, thread=nil)
+      def fake_transaction_finished(name, start_timestamp, duration, thread, bucket=:request)
         payload = {
-          :name => name,
+          :name            => name,
+          :bucket          => bucket,
           :start_timestamp => start_timestamp,
-          :duration => duration
+          :duration        => duration
         }
         payload[:thread] = thread if thread
         @event_listener.notify(:transaction_finished, payload)

data/test/new_relic/agent/transaction_event_aggregator_test.rb

@@ -91,7 +91,6 @@ class NewRelic::Agent::TransactionEventAggregatorTest < Minitest::Test
     txn_metrics.record_unscoped('External/allWeb',       14)
     txn_metrics.record_unscoped('Datastore/all',         15)
     txn_metrics.record_unscoped("GC/Transaction/all",    16)
-    txn_metrics.record_unscoped('Memcache/allWeb',       17)
 
     with_sampler_config do
       generate_request('name', :metrics => txn_metrics)
@@ -100,7 +99,6 @@ class NewRelic::Agent::TransactionEventAggregatorTest < Minitest::Test
       assert_equal 14, event_data["externalDuration"]
       assert_equal 15, event_data["databaseDuration"]
       assert_equal 16, event_data["gcCumulative"]
-      assert_equal 17, event_data["memcacheDuration"]
 
       assert_equal 1, event_data["externalCallCount"]
       assert_equal 1, event_data["databaseCallCount"]
@@ -112,7 +110,6 @@ class NewRelic::Agent::TransactionEventAggregatorTest < Minitest::Test
     txn_metrics.record_unscoped('External/allOther',  12)
     txn_metrics.record_unscoped('Datastore/all',      13)
     txn_metrics.record_unscoped("GC/Transaction/all", 14)
-    txn_metrics.record_unscoped('Memcache/allOther',  15)
 
     with_sampler_config do
       generate_request('name', :metrics => txn_metrics)
@@ -121,7 +118,6 @@ class NewRelic::Agent::TransactionEventAggregatorTest < Minitest::Test
       assert_equal 12, event_data["externalDuration"]
       assert_equal 13, event_data["databaseDuration"]
       assert_equal 14, event_data["gcCumulative"]
-      assert_equal 15, event_data["memcacheDuration"]
 
       assert_equal 1, event_data["databaseCallCount"]
       assert_equal 1, event_data["externalCallCount"]

data/test/new_relic/agent/transaction_test.rb

@@ -132,6 +132,7 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
   KEY_TRANSACTION_CONFIG = {
       :web_transactions_apdex => {
         'Controller/slow/txn' => 4,
+        'OtherTransaction/back/ground' => 8
       },
       :apdex => 1
   }
@@ -150,6 +151,7 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
 
       # apdex_s is 2 because the transaction itself records apdex
       assert_metrics_recorded(
+        'ApdexAll'       => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 },
         'Apdex'          => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 },
         'Apdex/slow/txn' => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 }
       )
@@ -170,12 +172,47 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
 
       # apdex_s is 2 because the transaction itself records apdex
       assert_metrics_recorded(
+        'ApdexAll'        => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 },
         'Apdex'           => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 },
         'Apdex/other/txn' => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 }
       )
     end
   end
 
+  def test_update_apdex_records_for_background_key_transaction
+    t0 = freeze_time
+    with_config(KEY_TRANSACTION_CONFIG) do
+      in_background_transaction('OtherTransaction/back/ground') do
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        txn.record_apdex(state, t0 + 7.5)
+        txn.record_apdex(state, t0 + 9.5)
+        txn.record_apdex(state, t0 + 32.5)
+      end
+
+      assert_metrics_recorded(
+        'ApdexAll'   => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 },
+        'ApdexOther' => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 },
+        'ApdexOther/Transaction/back/ground' => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 }
+      )
+    end
+  end
+
+  def test_skips_apdex_records_for_background_non_key_transaction
+    t0 = freeze_time
+    with_config(KEY_TRANSACTION_CONFIG) do
+      in_background_transaction('OtherTransaction/other/task') do
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        txn.record_apdex(state, t0 + 7.5)
+        txn.record_apdex(state, t0 + 9.5)
+        txn.record_apdex(state, t0 + 32.5)
+      end
+
+      refute_metrics_recorded(['ApdexOther', 'ApdexOther/Transaction/other/task'])
+    end
+  end
+
   def test_record_apdex_stores_apdex_t_in_min_and_max
     with_config(:apdex_t => 2.5) do
       in_web_transaction('Controller/some/txn') do
@@ -187,11 +224,42 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
 
     expected = { :min_call_time => 2.5, :max_call_time => 2.5 }
     assert_metrics_recorded(
-      'Apdex' => expected,
+      'ApdexAll'       => expected,
+      'Apdex'          => expected,
       'Apdex/some/txn' => expected
     )
   end
 
+  def test_records_apdex_all_for_both_transaction_types
+    t0 = freeze_time
+    with_config(KEY_TRANSACTION_CONFIG) do
+      in_background_transaction('OtherTransaction/back/ground') do
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        txn.record_apdex(state, t0 + 7.5)
+        txn.record_apdex(state, t0 + 9.5)
+        txn.record_apdex(state, t0 + 32.5)
+      end
+
+      in_web_transaction('Controller/slow/txn') do
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        txn.record_apdex(state, t0 +  3.5)
+        txn.record_apdex(state, t0 +  5.5)
+        txn.record_apdex(state, t0 + 16.5)
+      end
+
+      # apdex_s is 2 because the transaction itself records apdex
+      assert_metrics_recorded(
+        'ApdexAll'       => { :apdex_s => 4, :apdex_t => 2, :apdex_f => 2 },
+        'Apdex'          => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 },
+        'Apdex/slow/txn' => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 },
+        'ApdexOther'     => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 },
+        'ApdexOther/Transaction/back/ground' => { :apdex_s => 2, :apdex_t => 1, :apdex_f => 1 }
+      )
+    end
+  end
+
   class SillyError < StandardError
   end
 
@@ -429,7 +497,7 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     end
   end
 
-  def test_background_transaction_event_doesnt_include_apdex_perf_zone
+  def test_default_background_transaction_event_doesnt_include_apdex_perf_zone
     apdex = nil
     NewRelic::Agent.subscribe(:transaction_finished) do |payload|
       apdex = payload[:apdex_perf_zone]
@@ -443,6 +511,29 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     end
   end
 
+  def test_background_transaction_event_include_apdex_perf_zone_if_key_transaction
+    apdex = nil
+    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
+      apdex = payload[:apdex_perf_zone]
+    end
+
+    freeze_time
+
+    txn_name = 'OtherTransaction/back/ground'
+    key_transactions = { txn_name => 1.0 }
+
+    with_config(:apdex_t => 1.0, :web_transactions_apdex => key_transactions) do
+      in_background_transaction(txn_name) { advance_time 0.5 }
+      assert_equal('S', apdex)
+
+      in_background_transaction(txn_name) { advance_time 1.5 }
+      assert_equal('T', apdex)
+
+      in_background_transaction(txn_name) { advance_time 4.5 }
+      assert_equal('F', apdex)
+    end
+  end
+
   def test_guid_in_finish_event_payload_if_incoming_synthetics_header
     keys = []
     NewRelic::Agent.subscribe(:transaction_finished) do |payload|
@@ -1186,4 +1277,11 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
 
     assert_metrics_recorded(["Errors/all"])
   end
+
+  def test_instrumentation_state
+    in_transaction do |txn|
+      txn.instrumentation_state[:a] = 42
+      assert_equal(42, txn.instrumentation_state[:a])
+    end
+  end
 end

data/test/new_relic/agent_test.rb

@@ -310,7 +310,7 @@ module NewRelic
         new_name = NewRelic::Agent.get_transaction_name + "2"
         NewRelic::Agent.set_transaction_name(new_name)
       end
-      assert engine.lookup_stats('OtherTransaction/Background/a_new_name2')
+      assert_metrics_recorded 'OtherTransaction/Background/a_new_name2'
     end
 
     def test_set_transaction_name_applies_proper_scopes
@@ -343,7 +343,7 @@ module NewRelic
           NewRelic::Agent.set_transaction_name('new_name')
         end
       end
-      assert_nil engine.lookup_stats('Controller/new_name')
+      refute_metrics_recorded('Controller/new_name')
     end
 
     def test_set_transaction_name_applies_category
@@ -374,7 +374,7 @@ module NewRelic
       Transactor.new.task_txn do
         NewRelic::Agent.set_transaction_name('new_name')
       end
-      assert engine.lookup_stats('OtherTransaction/Background/new_name')
+      assert_metrics_recorded 'OtherTransaction/Background/new_name'
     end
 
     # It's not uncommon for customers to conclude a rescue block with a call to

data/test/new_relic/http_client_test_cases.rb

@@ -5,7 +5,6 @@
 require "newrelic_rpm"
 require "fake_external_server"
 require "evil_server"
-require 'multiverse_helpers'
 
 module HttpClientTestCases
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation,

data/test/new_relic/multiverse_helpers.rb

@@ -4,6 +4,13 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "agent_helper"))
 
+class Minitest::Test
+  def after_teardown
+    unfreeze_time
+    super
+  end
+end
+
 module MultiverseHelpers
 
   #

data/test/new_relic/transaction_ignoring_test_cases.rb

@@ -2,8 +2,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-require 'multiverse_helpers'
-
 module TransactionIgnoringTestCases
 
   include MultiverseHelpers

data/test/new_relic/transaction_sample_test.rb

@@ -24,7 +24,7 @@ class NewRelic::TransactionSampleTest < Minitest::Test
     @connection_stub.stubs(:execute).returns(dummy_mysql_explain_result({'foo' => 'bar'}))
 
     NewRelic::Agent::Database.stubs(:get_connection).returns @connection_stub
-    @t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    @t = make_sql_transaction(::SQL_STATEMENT)
 
     if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
       @marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
@@ -314,7 +314,7 @@ class NewRelic::TransactionSampleTest < Minitest::Test
 
     t = nil
     with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
-      t = make_sql_transaction(query, query)
+      t = make_sql_transaction(query)
       t.prepare_to_send!
     end
 
@@ -322,6 +322,15 @@ class NewRelic::TransactionSampleTest < Minitest::Test
     assert_equal(["SELECT * FROM table WHERE col1=? AND col2=?"], sql_statements)
   end
 
+  def test_multiple_calls_to_notice_sequel_appends_sql
+    queries = ["BEGIN", "INSERT items(title) VALUES('title')", "COMMIT"]
+
+    t = make_sql_transaction(*queries)
+    sql_statements = extract_captured_sql(t)
+
+    assert_equal [queries.join("\n")], sql_statements
+  end
+
   def trace_tree(transaction=@t)
     if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
       trace_tree = compress(JSON.dump(transaction.to_array))

data/test/performance/README.md

@@ -30,7 +30,7 @@ Run one specific suite:
 $ rake test:performance[TransactionTracingPerfTests]
 ```
 
-Run one specif suite and test (test name matching is via regex):
+Run one specific suite and test (test name matching is via regex):
 
 ```
 $ rake test:performance[TransactionTracingPerfTests,test_short_transactions]
@@ -39,7 +39,7 @@ $ rake test:performance[TransactionTracingPerfTests,test_short_transactions]
 ### Invoking via the runner directly
 
 More advanced options can be specified by invoking the runner script directly.
-See `test/performance/script/runner -h` for a full list of options.
+See `./test/performance/script/runner -h` for a full list of options.
 
 Run all tests, report detailed results in a human-readable form
 
@@ -47,16 +47,35 @@ Run all tests, report detailed results in a human-readable form
 $ ./test/performance/script/runner
 ```
 
+List all available test suites and names:
+
+```
+$ ./test/performance/script/runner -l
+```
+
 Run a specific test (test name matching is via regex):
 
 ```
 $ ./test/performance/script/runner -n short
 ```
 
-Run all the tests, brief output (just timings):
+To compare results for a specific test between two versions of the code, use the
+`-B` (for Baseline) and `-C` for (for Compare) switches:
 
 ```
-$ ./test/performance/script/runner -b
+$ ./test/performance/script/runner -n short -B
+1 tests, 0 failures, 8.199975 s total
+Saved 1 results as baseline.
+
+... switch to another branch and run again with -C ...
+
+$ ./test/performance/script/runner -n short -C
+1 tests, 0 failures, 8.220509 s total
++-----------------------------------------------------+-----------+-----------+-------+---------------+--------------+--------------+
+| name                                                | before    | after     | delta | allocs_before | allocs_after | allocs_delta |
+|-----------------------------------------------------+-----------+-----------+-------+---------------+--------------+--------------|
+| TransactionTracingPerfTests#test_short_transactions | 214.27 µs | 210.31 µs | -1.8% |            97 |           97 |         0.0% |
++-----------------------------------------------------+-----------+-----------+-------+---------------+--------------+--------------+
 ```
 
 Run all the tests, produce machine readable JSON output (for eventual ingestion into a storage system):
@@ -65,16 +84,16 @@ Run all the tests, produce machine readable JSON output (for eventual ingestion
 $ ./test/performance/script/runner -j | json_reformat
 ```
 
-Run a specific test using the perftools.rb CPU profiler, producing a call-graph style dot file:
+Run a specific test under a profiler (either stackprof or perftools.rb, depending on your Ruby version):
 
 ```
-$ ./test/performance/script/runner -n short -i PerfToolsProfile
+$ ./test/performance/script/runner -n short --profile
 ```
 
-Run with fewer iterations, and do object allocation profiling (again to a call-graph dot file):
+Run with a set number of iterations, and do object allocation profiling (again to a call-graph dot file):
 
 ```
-$ CPUPROFILE_OBJECTS=1 ./test/performance/script/runner -n short -i PerfToolsProfile -N 1000
+$ ./test/performance/script/runner -n short -a -N 1000
 ```
 
 ## Pointing at a different copy of the agent
@@ -100,16 +119,17 @@ under `test/performance/suites`, subclass `Performance::TestCase`, and write
 test methods that start with `test_`. You can also write `setup` and `teardown`
 methods that will be run before/after each test.
 
-Generally in your test, you'll want to do some operation N times (where N is
-large). You should base your N on the return value of
-`Performance::TestCase#iterations`, which is controlled by the `-N` command-line
-flag to `runner`. You may scale this value linearly as appropriate for your test
-if need be, but the idea is to have a single knob to turn that will change the
-iteration count for all tests.
+Within your `test_` method, you must call `measure` and pass it a block
+containing the code that you'd like to actually measure the timing of. This
+allows you to do test-specific setup that doesn't get counted towards your
+test timing.
+
+The block that you pass to `measure` will automatically be run in a loop for a
+fixed amount of time by the performance runner harness (5s by default), and the
+number of iterations performed will be recorded so that measurements can be
+normalized to per-iteration values.
 
-The invocation of each `test_*` method will be timed, so any setup / teardown
-you need for your test that you don't want included in the timing should be
-confined to the `setup` and `teardown` methods.
+You can look at the [existing tests](suites) for examples.
 
 ## Test Isolation