newrelic_rpm 3.6.5.130 → 3.6.6.147

data/test/new_relic/metric_spec_test.rb

@@ -76,6 +76,24 @@ class NewRelic::MetricSpecTest < Test::Unit::TestCase
     assert_equal("b" * 255, spec.scope, "should have shortened the scope")
   end
 
+  def test_invalid_name_setting_nil
+    NewRelic::Agent.instance.error_collector.errors.clear
+
+    spec = NewRelic::MetricSpec.new
+    spec.scope = nil
+
+    assert_has_error(NewRelic::MetricSpec::InvalidScopeSettingError)
+  end
+
+  def test_invalid_name_setting_false
+    NewRelic::Agent.instance.error_collector.errors.clear
+
+    spec = NewRelic::MetricSpec.new
+    spec.scope = false
+
+    assert_has_error(NewRelic::MetricSpec::InvalidScopeSettingError)
+  end
+
   private
 
   def compare_spec(spec, import)

data/test/new_relic/multiverse_helpers.rb

@@ -0,0 +1,164 @@
+# 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 MultiverseHelpers
+
+  #
+  # Agent startup/shutdown
+  #
+  # These are considered to be the standard steps for each test to take.
+  # If your tests do something different, it's important that they clean up
+  # after themselves!
+
+  def self.included(base)
+    base.extend(self)
+  end
+
+  def agent
+    NewRelic::Agent.instance
+  end
+
+  def setup_and_teardown_agent(opts = {}, &block)
+    define_method(:setup) do
+      before_setup if respond_to?(:before_setup)
+      setup_agent(opts, &block)
+      after_setup if respond_to?(:after_setup)
+    end
+
+    define_method(:teardown) do
+      before_teardown if respond_to?(:before_teardown)
+      teardown_agent
+      after_teardown if respond_to?(:after_teardown)
+    end
+  end
+
+  def setup_agent(opts = {}, &block)
+    setup_collector
+    make_sure_agent_reconnects(opts)
+
+    # Give caller a shot to setup before we start
+    # Don't just yield, as that won't necessary have the intended receiver
+    # (the test case instance itself)
+    self.instance_exec($collector, &block) if block_given? && self.respond_to?(:instance_exec)
+
+    NewRelic::Agent.manual_start(opts)
+  end
+
+  def teardown_agent
+    reset_collector
+
+    # Put the configs back where they belong....
+    NewRelic::Agent.config.reset_to_defaults
+
+    # Renaming rules don't get cleared on connect--only appended to
+    NewRelic::Agent.instance.transaction_rules.rules.clear
+    NewRelic::Agent.instance.metric_rules.rules.clear
+
+    # Clear out lingering stats we didn't transmit
+    NewRelic::Agent.instance.reset_stats
+
+    # Clear out lingering errors in the collector
+    NewRelic::Agent.instance.error_collector.harvest_errors(nil)
+    NewRelic::Agent.instance.error_collector.instance_variable_set(:@ignore_filter, nil)
+
+    # Clear out the request sampler!
+    NewRelic::Agent.instance.instance_variable_get(:@request_sampler).reset
+
+    # Clean up any thread-local variables starting with 'newrelic'
+    Thread.current.keys.select { |k| k.to_s =~ /^newrelic/i }.each do |key|
+      Thread.current[key] = nil
+    end
+
+    NewRelic::Agent.shutdown
+  end
+
+  def run_agent(options={}, &block)
+    setup_agent(options)
+    yield if block_given?
+    teardown_agent
+  end
+
+  def make_sure_agent_reconnects(opts)
+    # Clean-up if others don't (or we're first test after auto-loading of agent)
+    if NewRelic::Agent.instance.started?
+      NewRelic::Agent.shutdown
+      NewRelic::Agent.logger.warn("TESTING: Agent wasn't shut down before test")
+    end
+
+    # This will force a reconnect when we start again
+    NewRelic::Agent.instance.instance_variable_set(:@connect_state, :pending)
+
+    # Almost always want a test to force a new connect when setting up
+    default_options(opts,
+                    :sync_startup => true,
+                    :force_reconnect => true)
+  end
+
+  def default_options(options, defaults={})
+    defaults.each do |(k, v)|
+      options.merge!({k => v}) unless options.key?(k)
+    end
+  end
+
+  #
+  # Collector interactions
+  #
+  # These are here to ease interactions with the fake collector, and allow
+  # classes that don't need them to avoid it by an environment variable.
+  # This helps so the runner process can decide before spawning the child
+  # whether we want the collector running or not.
+
+  def setup_collector
+    return if omit_collector?
+
+    require 'fake_collector'
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    $collector.run
+
+    if (NewRelic::Agent.instance &&
+        NewRelic::Agent.instance.service &&
+        NewRelic::Agent.instance.service.collector)
+      NewRelic::Agent.instance.service.collector.port = $collector.port
+    end
+  end
+
+  def reset_collector
+    return if omit_collector?
+    $collector.reset
+  end
+
+  def omit_collector?
+    ENV["NEWRELIC_OMIT_FAKE_COLLECTOR"] == "true"
+  end
+
+  extend self
+end
+
+if RUBY_VERSION < "1.8.7"
+  # No instance_exec in 1.8.6... sigh
+  #
+  # Cribbed from https://www.ruby-forum.com/topic/72172#101957, most straight
+  # forward implementation I could find without using ActiveSupport
+  class Object
+    unless defined? instance_exec # 1.9
+      def instance_exec(*arguments, &block)
+        block.bind(self)[*arguments]
+      end
+    end
+  end
+
+  class Proc
+    def bind(object)
+      block, time = self, Time.now
+      (class << object; self end).class_eval do
+        method_name = "__bind_#{time.to_i}_#{time.usec}"
+        define_method(method_name, &block)
+        method = instance_method(method_name)
+        remove_method(method_name)
+        method
+      end.bind(object)
+    end
+  end
+end

data/test/new_relic/rack/agent_hooks_test.rb

@@ -38,4 +38,3 @@ class AgentHooksTest < Test::Unit::TestCase
   end
 
 end
-

data/test/new_relic/rack/all_test.rb

@@ -12,4 +12,3 @@ class NewRelic::Rack::AllTest < Test::Unit::TestCase
     assert true
   end
 end
-

data/test/new_relic/rack/deferred_instrumentation_test.rb

@@ -0,0 +1,35 @@
+# 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::Rack::DeferredInstrumentationTest < Test::Unit::TestCase
+  class TestApp
+    def call(env)
+      [200, {}, ["whatever"]]
+    end
+  end
+
+  def test_to_app_does_not_blow_up_when_rack_instrumentation_required_multiple_times
+    # We want to use two different paths to require the rack instrumentation here
+    # in order to simulate a situation that might arise where a user is
+    # explicitly requiring our rack instrumentation file, and then the agent
+    # automatically requires it as well, via a different path.
+    # On Ruby 1.8.7, this will cause the file to be evaluated multiple times.
+    path1 = "new_relic/agent/instrumentation/rack"
+    path2 = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'lib', 'new_relic', 'agent', 'instrumentation', 'rack'))
+    assert_not_equal(path2, path1)
+
+    require path1
+    require path2
+
+    builder = ::Rack::Builder.new do
+      run(::NewRelic::Rack::DeferredInstrumentationTest::TestApp.new)
+    end
+
+    assert_nothing_raised do
+      builder.to_app
+    end
+  end
+end

data/test/new_relic/rack/developer_mode_helper_test.rb

@@ -2,7 +2,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-# ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..', '..',
                                    'test_helper'))
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','ui',
@@ -11,8 +10,8 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','ui',
 ENV['RACK_ENV'] = 'test'
 class DeveloperModeTest < Test::Unit::TestCase
   include NewRelic::DeveloperModeHelper
-  
-  
+
+
   def test_application_caller
     assert_equal "/opt/ruby/lib/ruby/1.8/net/protocol.rb:135:in `rbuf_fill'", application_caller(Fixtures::NORMAL_TRACE)
     assert_equal "c:/Ruby192/lib/ruby/1.9.1/erb.rb:753:in `eval'", application_caller(Fixtures::WINDOWS_TRACE)
@@ -23,16 +22,16 @@ class DeveloperModeTest < Test::Unit::TestCase
     assert_equal 29, trace.size
     trace = application_stack_trace(Fixtures::WINDOWS_TRACE)
     assert_equal 14, trace.size
-    
+
   end
-  
+
   def test_url_for_source
     for line in Fixtures::NORMAL_TRACE + Fixtures::WINDOWS_TRACE do
       line = url_for_source(line)
       assert line =~ /^show_source\?file=.*&amp;line=\d+&amp;/, line
     end
   end
-  
+
   private
   def params; {} end
   module Fixtures
@@ -105,9 +104,9 @@ rack (1.2.3) lib/rack/content_length.rb:13:in `call'
 rack (1.2.3) lib/rack/handler/webrick.rb:52:in `service'
 c:/Ruby192/lib/ruby/1.9.1/webrick/httpserver.rb:111:in `service'
 c:/Ruby192/lib/ruby/1.9.1/webrick/httpserver.rb:70:in `run'
-c:/Ruby192/lib/ruby/1.9.1/webrick/server.rb:183:in `block in start_thread'  
+c:/Ruby192/lib/ruby/1.9.1/webrick/server.rb:183:in `block in start_thread'
   EOF
-    
+
     NORMAL_TRACE = <<-EOF.split("\n")
 /opt/ruby/lib/ruby/1.8/net/protocol.rb:135:in `rbuf_fill'
 /opt/ruby/lib/ruby/1.8/timeout.rb:101:in `timeout'
@@ -141,5 +140,5 @@ c:/Ruby192/lib/ruby/1.9.1/webrick/server.rb:183:in `block in start_thread'
 /Users/joe/dev/workspace/config/initializers/delayed_job_with_shards.rb:17:in `perform'
 /opt/ruby/gems/delayed_job-2.0.6/lib/delayed/backend/base.rb:74:in `invoke_job'
   EOF
-  end  
+  end
 end

data/test/new_relic/rack/developer_mode_test.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.
 
-# ENV['SKIP_RAILS'] = 'true'
-
 if defined?(::Rails)
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..', '..',

data/test/new_relic/rack/error_collector_test.rb

@@ -45,8 +45,7 @@ module NewRelic::Rack
         get '/'
       end
 
-      assert_equal('unhandled error',
-                   NewRelic::Agent.instance.error_collector.errors[0].message)
+      assert_equal('unhandled error', last_error.message)
     end
 
     def test_ignore_filtered_errors
@@ -76,20 +75,65 @@ module NewRelic::Rack
     end
 
     def test_handles_parameter_parsing_exceptions
-      bad_request = stub(:env => {}, :path => '/', :referer => '')
-      bad_request.stubs(:params).raises(TypeError, "can't convert nil into Hash")
-      Rack::Request.stubs(:new).returns(bad_request)
+      if defined?(ActionDispatch::Request)
+        bad_request = stub.stubs(:filtered_params).raises(TypeError, "can't convert nil into Hash")
+        ActionDispatch::Request.stubs(:new).returns(bad_request)
+      else
+        bad_request = stub(:env => {}, :path => '/', :referer => '')
+        bad_request.stubs(:params).raises(TypeError, "whatever, man")
+        Rack::Request.stubs(:new).returns(bad_request)
+      end
 
       assert_raise RuntimeError do
         get '/'
       end
 
-      assert_equal('unhandled error',
-                   NewRelic::Agent.instance.error_collector.errors[0].message)
+      assert_equal('unhandled error', last_error.message)
       assert_match(/failed to capture request parameters/i,
-                   NewRelic::Agent.instance.error_collector.errors[0].params[:request_params]['error'])
+                   last_error.params[:request_params]['error'])
+    end
+
+    # Ideally we'd test this for failures to create Rack::Request as well,
+    # but unfortunately rack-test, which we're using to drive, creates
+    # Rack::Request objects internally, so there's not an easy way to.
+    def test_handles_failure_to_create_request_object
+      if defined?(ActionDispatch::Request)
+        ActionDispatch::Request.stubs(:new).raises('bad news')
+
+        assert_raise RuntimeError do
+          get '/foo/bar?q=12'
+        end
+
+        assert_equal('unhandled error', last_error.message)
+        assert_equal('/foo/bar', last_error.params[:request_uri])
+      end
+    end
+
+    def test_captures_parameters_with_rails
+      assert_raise RuntimeError do
+        get '/?foo=bar&baz=qux'
+      end
+
+      expected_params = { 'foo' => 'bar', 'baz' => 'qux' }
+      assert_equal('unhandled error', last_error.message)
+      assert_equal(expected_params, last_error.params[:request_params])
+    end
+
+    def test_captures_parameters_without_rails
+      undefine_constant(:'ActionDispatch::Request') do
+        assert_raise RuntimeError do
+          get '/?foo=bar&baz=qux'
+        end
+      end
+
+      expected_params = { 'foo' => 'bar', 'baz' => 'qux' }
+      assert_equal('unhandled error', last_error.message)
+      assert_equal(expected_params, last_error.params[:request_params])
     end
 
+    def last_error
+      NewRelic::Agent.instance.error_collector.errors[0]
+    end
   end
 end
 

data/test/new_relic/transaction_sample/composite_segment_test.rb

@@ -36,4 +36,3 @@ class NewRelic::TransactionSample::CompositeSegmentTest < Test::Unit::TestCase
     segment
   end
 end
-

data/test/new_relic/transaction_sample/fake_segment_test.rb

@@ -18,4 +18,3 @@ class NewRelic::TransactionSample::FakeSegmentTest < Test::Unit::TestCase
     assert_equal('foo', s.instance_eval { @parent_segment } )
   end
 end
-

data/test/new_relic/transaction_sample/segment_test.rb

@@ -377,4 +377,3 @@ class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
     assert_equal(fake_segment, s.parent_segment)
   end
 end
-

data/test/new_relic/transaction_sample/summary_segment_test.rb

@@ -32,4 +32,3 @@ class NewRelic::TransactionSample::SummarySegmentTest < Test::Unit::TestCase
     segment
   end
 end
-

data/test/performance/README.md

@@ -0,0 +1,162 @@
+# 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 specif 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
+```
+
+Run a specific test (test name matching is via regex):
+
+```
+$ ./test/performance/script/runner -n short
+```
+
+Run all the tests, brief output (just timings):
+
+```
+$ ./test/performance/script/runner -b
+```
+
+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 using the perftools.rb CPU profiler, producing a call-graph style dot file:
+
+```
+$ ./test/performance/script/runner -n short -i PerfToolsProfile
+```
+
+Run with fewer 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
+```
+
+## 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.
+
+## Sending results to Hako
+
+This is currently considered experimental, but you can send results
+automatically to Hako by passing `-R HakoReporter` on the command line to the
+`runner`. This will produce JSON-formatted versions of each test result, and
+submit them to Hako. You will need to set the `HAKO_TOKEN` environment variable
+to a valid Hako access token when doing this.
+
+## 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.
+
+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.
+
+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.
+
+## 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
+avaiable**.
+
+Not all command-line options to the runner work with this test isolation yet.
+You can disable it by passing the `-I/--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 imlement 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.