newrelic_rpm 4.1.0.333 → 4.2.0.334

data/test/new_relic/transaction_ignoring_test_cases.rb

@@ -1,102 +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.
-
-module TransactionIgnoringTestCases
-
-  include MultiverseHelpers
-
-  TXN_PREFIX = 'Controller/'
-
-  setup_and_teardown_agent do |collector|
-    collector.stub('connect', {
-      'transaction_name_rules' => [{"match_expression" => "ignored_transaction",
-                                    "ignore"           => true}],
-      'agent_run_id' => 1,
-    })
-  end
-
-  # Test classes that include this module are expected to define:
-  #   trigger_transaction(txn_name)
-  #   trigger_transaction_with_error(txn_name, error_msg)
-  #   trigger_transaction_with_slow_sql(txn_name)
-
-
-  def test_does_not_record_metrics_for_ignored_transaction
-    trigger_transaction('accepted_transaction')
-    trigger_transaction('ignored_transaction')
-
-    NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
-
-    stats = $collector.reported_stats_for_metric(TXN_PREFIX+'accepted_transaction')
-    assert_equal(1, stats.size)
-
-    stats = $collector.reported_stats_for_metric(TXN_PREFIX+'ignored_transaction')
-    assert_equal(0, stats.size)
-  end
-
-  def test_does_not_record_traced_errors_for_ignored_transactions
-    trigger_transaction_with_error('ignored_transaction',  'Buffy dies :(')
-    trigger_transaction_with_error('accepted_transaction', 'Buffy lives :)')
-
-    NewRelic::Agent.instance.send(:harvest_and_send_errors)
-
-    posts = $collector.calls_for('error_data')
-    assert_equal(1, posts.size)
-
-    errors = posts.first.errors
-
-    assert_equal(1, errors.size)
-    assert_equal('Buffy lives :)', errors.first.message)
-  end
-
-  def test_does_not_record_transaction_trace_for_ignored_transactions
-    with_config(:'transaction_tracer.transaction_threshold' => 0) do
-      trigger_transaction('accepted_transaction')
-      NewRelic::Agent.instance.send(:harvest_and_send_transaction_traces)
-      assert_equal(1, $collector.calls_for('transaction_sample_data').size)
-
-      trigger_transaction('ignored_transaction')
-      NewRelic::Agent.instance.send(:harvest_and_send_transaction_traces)
-      assert_equal(1, $collector.calls_for('transaction_sample_data').size)
-    end
-  end
-
-  def test_does_not_record_analytics_for_ignored_transactions
-    trigger_transaction('ignored_transaction')
-    trigger_transaction('accepted_transaction')
-
-    NewRelic::Agent.instance.send(:harvest_and_send_analytic_event_data)
-
-    posts = $collector.calls_for('analytic_event_data')
-    assert_equal(1, posts.size)
-
-    events = posts.first.events
-
-    assert_equal(1, events.size)
-    assert_equal(TXN_PREFIX+'accepted_transaction', events.first[0]['name'])
-  end
-
-  def test_does_not_record_sql_traces_for_ignored_transactions
-    trigger_transaction_with_slow_sql('ignored_transaction')
-    trigger_transaction_with_slow_sql('accepted_transaction')
-
-    NewRelic::Agent.instance.send(:harvest_and_send_slowest_sql)
-
-    posts = $collector.calls_for('sql_trace_data')
-    assert_equal(1, posts.size)
-
-    traces = posts.first.traces
-
-    assert_equal(1, traces.size)
-
-    trace = traces.first
-
-    # From SqlTrace#to_collector_array
-    # 0 -> path
-    # 5 -> call_count
-    assert_equal(TXN_PREFIX+'accepted_transaction', trace[0])
-    assert_equal(1, trace[5])
-  end
-
-end

data/test/nullverse/default_source_require_test.rb

@@ -1,21 +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__), 'nullverse_helper'))
-
-# this test exists to ensure that default source doesn't depend on specific parts
-# of the agent having been previously required when default_source is required.
-
-class DefaultSourceRequireTest < Minitest::Test
-  def test_require_default_source_doesnt_raise
-    exception = nil
-    begin
-      require 'new_relic/agent/configuration/default_source'
-    rescue => e
-      exception = e
-    end
-
-    assert_nil exception, "Expected not to raise when requiring default source without the agent"
-  end
-end

data/test/nullverse/nullverse_helper.rb

@@ -1,10 +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 'minitest/autorun'
-
-unless defined?(Minitest::Test)
-  Minitest::Test = MiniTest::Unit::TestCase
-end
-
-$:.unshift File.expand_path('../../../lib', __FILE__)

data/test/performance/README.md

@@ -1,175 +0,0 @@
-# Ruby Agent Performance Tests
-
-This is a performance testing framework for the Ruby Agent.
-
-## Motivation
-
-There are two main goals driving the development of this framework:
-
-1. Add a way for automated performance tests to be run against the Ruby Agent
-   and ingested into a system for tracking these results over time.
-2. Provide a tool for Ruby Agent engineers to use while working on performance
-   improvements.
-
-## Examples
-
-### Invoking via rake task
-
-Basic performance test invocations can be done using a rake task provided in the
-newrelic_rpm Rakefile.
-
-Run all performance tests, reporting results to the console:
-
-```
-$ rake test:performance
-```
-
-Run one specific suite:
-
-```
-$ rake test:performance[TransactionTracingPerfTests]
-```
-
-Run one specific suite and test (test name matching is via regex):
-
-```
-$ 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.
-
-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
-```
-
-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 -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):
-
-```
-$ ./test/performance/script/runner -j | json_reformat
-```
-
-Run a specific test under a profiler (either stackprof or perftools.rb, depending on your Ruby version):
-
-```
-$ ./test/performance/script/runner -n short --profile
-```
-
-Run with a set number of iterations, and do object allocation profiling (again to a call-graph dot file):
-
-```
-$ ./test/performance/script/runner -n short -a -N 1000
-```
-
-## Pointing at a different copy of the agent
-
-If you want to run performance tests against an older copy of the agent that
-doesn't have the performance test framework embedded within it, you can do that
-by specifying the path to the agent you want to test against by passing the `-A`
-flag to the `runner` script, or by setting the `AGENT_PATH` environment variable
-when using the rake task.
-
-
-## Writing tests
-
-Performance tests are written in the style of `test/unit`: create a `.rb` file
-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.
-
-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.
-
-You can look at the [existing tests](suites) for examples.
-
-## Test Isolation
-
-Initial testing suggested that certain kinds of tests would have a large impact
-on tests run later on in the same process (e.g. tests that create lots of
-long-lived objects will slow down all future GC runs for as long as those
-objects remain live).
-
-In order to address this problem, the test runner will attempt to isolate each
-test to its own process by re-spawning itself for each test invocation. This is
-done using `IO.popen` rather than `Process.fork` in order to maintain
-compatibility with JRuby.
-
-Additionally, when operating in this mode, the `newrelic_rpm` gem will not be
-loaded until *after* the fork call. This means that your **test cases must be
-loadable (though not necessarily runnable) without the `newrelic_rpm` gem
-available**.
-
-Not all command-line options to the runner work with this test isolation yet.
-You can disable it by passing the `-I` or `--inline` flag to the runner.
-
-## Adding instrumentation layers
-
-The GC stats that are collected with each test run, and the perftools.rb
-profiling are examples of Instrumentors which can be wrapped around each test run.
-
-The basic idea is that each instrumentor gets callbacks before and after each
-test, and add information to the test results, or attach artifacts (a fancy name
-for file paths, currently) to the result.
-
-Instrumentors inherit from `Performance::Instrumentation::Instrumentor`, and may
-constrain themselves to running only on certain platforms (see `instrumentor.rb`
-for a list) by calling the `platforms` method in their class definitions. They
-may also signal that they should be used by default by calling `on_by_default`.
-They should implement the `before`, `after` and `results` methods as follows:
-
-The `before` method is called before each test is run. The test class and test
-name are passed as arguments.
-
-The `after` method is called after each test is run. The test class, and test
-name are passed as arguments. Artifacts may be attached to the result here by
-appending to the `@artifacts` array. You may obtain paths to store artifacts at
-by calling `Performance::Instrumentation::Instrumentor#artifact_path` (see
-perf_tools.rb for an example).
-
-The `results` method must return a Hash of key-value pairs to be attached to the
-`Result` object produced by running each test.
-
-If your instrumentation layer needs to do one-time setup (requiring a gem, for
-example), implement the `setup` class method to do this setup.

data/test/performance/lib/performance.rb

@@ -1,38 +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 'logger'
-
-$: << File.expand_path('..', __FILE__)
-
-require 'performance/platform'
-require 'performance/result'
-require 'performance/runner'
-require 'performance/test_case'
-require 'performance/timer'
-require 'performance/instrumentor'
-
-require 'performance/reporting'
-require 'performance/table'
-require 'performance/console_reporter'
-require 'performance/json_reporter'
-require 'performance/formatting_helpers'
-
-require 'performance/hako_client'
-require 'performance/hako_reporter'
-
-require 'performance/baseline'
-require 'performance/baseline_save_reporter'
-require 'performance/baseline_compare_reporter'
-
-module Performance
-  def self.logger
-    log_path = ENV['LOG'] || $stderr
-    @logger ||= Logger.new(log_path)
-  end
-
-  def self.log_path=(path)
-    @logger = Logger.new(path)
-  end
-end

data/test/performance/lib/performance/baseline.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.
-
-module Performance
-  class Baseline
-    PERSIST_PATH = File.expand_path("~/.newrelic_rpm_baseline")
-
-    attr_reader :results
-
-    def self.load!
-      self.new.load!
-    end
-
-    def self.save!(results)
-      baseline = self.new
-      results.each { |r| baseline.results << r }
-      baseline.save!
-    end
-
-    def initialize
-      @results = []
-    end
-
-    def load!
-      result_hashes = JSON.parse(File.read(PERSIST_PATH))
-      @results = result_hashes.map { |h| Result.from_hash(h) }
-    end
-
-    def save!
-      File.open(PERSIST_PATH, "w") do |f|
-        f.write(JSON.dump(@results.map(&:to_h)))
-      end
-    end
-  end
-end

data/test/performance/lib/performance/baseline_compare_reporter.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.
-
-module Performance
-  class BaselineCompareReporter
-    include Reporting
-
-    def initialize(results, elapsed, options={})
-      @results = results
-      @elapsed = elapsed
-      @options = options
-    end
-
-    def report
-      report_summary
-
-      begin
-        baseline = Baseline.load!
-      rescue => e
-        puts "Failed to load baseline results: #{e}\n#{e.backtrace.join("\n\t")}"
-        return
-      end
-
-      report_successful_results(baseline, successes) unless successes.empty?
-      report_failed_results
-    end
-
-    def report_successful_results(baseline, results)
-      baseline_identifiers  = baseline.map(&:identifier)
-      new_identifiers       = results.map(&:identifier)
-      missing_from_baseline = new_identifiers - baseline_identifiers
-      missing_from_new      = baseline_identifiers - new_identifiers
-      common_identifiers    = new_identifiers & baseline_identifiers
-
-      if !missing_from_baseline.empty?
-        puts "The following tests were not found in the baseline results:\n"
-        missing_from_baseline.each do |identifier|
-          puts "  #{identifier}"
-        end
-        puts ""
-      end
-
-      if !missing_from_baseline.empty?
-        puts "The following tests were not found in the new results:\n"
-        missing_from_new.each do |identifier|
-          puts "  #{identifier}"
-        end
-        puts ""
-      end
-
-      rows = []
-
-      common_identifiers.each do |identifier|
-        old_result = baseline.find { |r| r.identifier == identifier}
-        new_result = results.find  { |r| r.identifier == identifier }
-
-        delta = new_result.time_per_iteration - old_result.time_per_iteration
-        percent_delta = delta / old_result.time_per_iteration * 100.0
-
-        allocations_before = old_result.measurements[:allocations]
-        allocations_after  = new_result.measurements[:allocations]
-        if allocations_before && allocations_after
-          # normalize allocation counts to be per-iteration
-          allocations_before /= old_result.iterations
-          allocations_after  /= new_result.iterations
-
-          allocations_delta  = allocations_after - allocations_before
-          allocations_delta_percent = allocations_delta.to_f / allocations_before * 100
-        else
-          allocations_delta_percent = 0
-        end
-
-        rows << [
-          identifier,
-          old_result.time_per_iteration,
-          new_result.time_per_iteration,
-          percent_delta,
-          allocations_before,
-          allocations_after,
-          allocations_delta_percent
-        ]
-      end
-
-      format_percent_delta = Proc.new { |v|
-        prefix = v > 0 ? "+" : ""
-        sprintf("#{prefix}%.1f%%", v)
-      }
-
-      table = Table.new(rows) do
-        column :name
-        column :before,        &(FormattingHelpers.method(:format_duration))
-        column :after,         &(FormattingHelpers.method(:format_duration))
-        column :delta,         &format_percent_delta
-        column :allocs_before
-        column :allocs_after
-        column :allocs_delta,  &format_percent_delta
-      end
-
-      puts table.render
-    end
-  end
-end