newrelic_rpm 3.9.1.236 → 3.9.2.239

data/test/new_relic/agent/database/sql_obfuscation_test.rb

@@ -0,0 +1,76 @@
+# 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'))
+
+module NewRelic::Agent::Database
+  class SqlObfuscationTest < Minitest::Test
+    attr_reader :obfuscator
+
+    def self.input_files(subdir=nil)
+      fixture_dir = File.join(cross_agent_tests_dir, "sql_obfuscation")
+      fixture_dir = File.join(fixture_dir, subdir) if subdir
+      Dir["#{fixture_dir}/*.sql"]
+    end
+
+    def self.adapter_from_input_file(input_file)
+      case input_file
+      when /\.postgres\.sql$/ then :postgresql
+      when /\.mysql\.sql$/    then :mysql
+      else nil
+      end
+    end
+
+    def self.name_for_input_file(input_file)
+      adapter = adapter_from_input_file(input_file)
+      basename = File.basename(input_file)
+      name = basename.gsub(/\.(postgres|mysql)?\.sql$/, '')
+      name += "_#{adapter}" if adapter
+      name
+    end
+
+    def obfuscated_filename(query_file)
+      query_file.gsub(".sql", ".obfuscated")
+    end
+
+    def strip_comments(text)
+      text.gsub(/^\s*#.*/, '').strip
+    end
+
+    def read_query(input_file)
+      adapter = self.class.adapter_from_input_file(input_file)
+      query = strip_comments(File.read(input_file))
+
+      if adapter
+        query = NewRelic::Agent::Database::Statement.new(query)
+        query.adapter = adapter.to_sym
+      end
+
+      query
+    end
+
+    # Normal queries
+    input_files.each do |input_file|
+      name = name_for_input_file(input_file)
+
+      define_method("test_sql_obfuscation_#{name}") do
+        query               = read_query(input_file)
+        expected_obfuscated = File.read(obfuscated_filename(input_file))
+        actual_obfuscated   = NewRelic::Agent::Database.obfuscate_sql(query)
+        assert_equal(expected_obfuscated, actual_obfuscated, "Failed to obfuscate query from #{input_file}\nQuery: #{query}")
+      end
+    end
+
+    # Malformed queries
+    input_files('malformed').each do |input_file|
+      name = name_for_input_file(input_file)
+
+      define_method("test_sql_obfuscation_malformed_#{name}") do
+        query = read_query(input_file)
+        actual_obfuscated = NewRelic::Agent::Database.obfuscate_sql(query)
+        assert_equal(NewRelic::Agent::Database::Obfuscator::FAILED_TO_OBFUSCATE_MESSAGE, actual_obfuscated, "Failed to obfuscate malformed query from #{input_file}\nQuery: #{query}")
+      end
+    end
+  end
+end

data/test/new_relic/agent/database_test.rb

@@ -297,44 +297,8 @@ class NewRelic::Agent::DatabaseTest < Minitest::Test
     assert_equal([], NewRelic::Agent::Database.explain_sql('SELECT', config, &@explainer))
   end
 
-  def test_obfuscation_mysql_basic
-    insert = %q[INSERT INTO `X` values("test",0, 1 , 2, 'test')]
-    assert_equal("INSERT INTO `X` values(?,?, ? , ?, ?)",
-                 NewRelic::Agent::Database.obfuscate_sql(insert))
-    select = %q[SELECT `table`.`column` FROM `table` WHERE `table`.`column` = 'value' AND `table`.`other_column` = "other value" LIMIT 1]
-    assert_equal(%q[SELECT `table`.`column` FROM `table` WHERE `table`.`column` = ? AND `table`.`other_column` = ? LIMIT ?],
-                 NewRelic::Agent::Database.obfuscate_sql(select))
-  end
-
-  def test_obfuscation_postgresql_basic
-    insert = NewRelic::Agent::Database::Statement.new(%q[INSERT INTO "X" values('test',0, 1 , 2, 'test')])
-    insert.adapter = :postgresql
-    assert_equal('INSERT INTO "X" values(?,?, ? , ?, ?)',
-                 NewRelic::Agent::Database.obfuscate_sql(insert))
-    select = NewRelic::Agent::Database::Statement.new(%q[SELECT "table"."column" FROM "table" WHERE "table"."column" = 'value' AND "table"."other_column" = 'other value' LIMIT 1])
-    select.adapter = :postgresql
-    assert_equal(%q[SELECT "table"."column" FROM "table" WHERE "table"."column" = ? AND "table"."other_column" = ? LIMIT ?],
-                 NewRelic::Agent::Database.obfuscate_sql(select))
-  end
-
-  def test_obfuscation_escaped_literals
-    insert = %q[INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son', """jim''s"" hat", "\"jim''s secret\"")]
-    assert_equal("INSERT INTO X values(?, ?,?, ? , ?, ?, ?)",
-                 NewRelic::Agent::Database.obfuscate_sql(insert))
-  end
-
-  def test_obfuscation_mysql_integers_in_identifiers
-    select = %q[SELECT * FROM `table_007` LIMIT 1]
-    assert_equal(%q[SELECT * FROM `table_007` LIMIT ?],
-                 NewRelic::Agent::Database.obfuscate_sql(select))
-  end
-
-  def test_obfuscation_postgresql_integers_in_identifiers
-    select = NewRelic::Agent::Database::Statement.new(%q[SELECT * FROM "table_007" LIMIT 1])
-    select.adapter = :postgresql
-    assert_equal(%q[SELECT * FROM "table_007" LIMIT ?],
-                 NewRelic::Agent::Database.obfuscate_sql(select))
-  end
+  # See SqlObfuscationTest, which uses cross agent tests for the basic SQL
+  # obfuscation test cases.
 
   def test_obfuscation_of_truncated_query
     insert = "INSERT INTO data (blah) VALUES ('abcdefg..."

data/test/new_relic/agent/error_collector/notice_error_test.rb

@@ -191,20 +191,33 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Minitest::Test
 
   def test_filtered_by_error_filter_empty
     # should return right away when there's no filter
-    @ignore_filter = nil
     assert !filtered_by_error_filter?(nil)
   end
 
   def test_filtered_by_error_filter_positive
     error = mocked_error
-    @ignore_filter = lambda { |x| assert_equal error, x; false  }
+    self.class.class_eval do
+      define_method(:ignore_filter_proc) do |e|
+        assert_equal(error, e)
+        false
+      end
+    end
     assert filtered_by_error_filter?(error)
+  ensure
+    self.class.class_eval { undef :ignore_filter_proc }
   end
 
   def test_filtered_by_error_filter_negative
     error = mocked_error
-    @ignore_filter = lambda { |x| assert_equal error, x; true  }
+    self.class.class_eval do
+      define_method(:ignore_filter_proc) do |e|
+        assert_equal(error, e)
+        true
+      end
+    end
     assert !filtered_by_error_filter?(error)
+  ensure
+    self.class.class_eval { undef :ignore_filter_proc }
   end
 
   def test_error_is_ignored_positive
@@ -240,4 +253,9 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Minitest::Test
       yield NewRelic::Agent::ErrorCollector.new
     end
   end
+
+  def ignore_error_filter
+    @ignore_filter
+  end
+
 end

data/test/new_relic/agent/error_collector_test.rb

@@ -20,6 +20,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
 
   def teardown
     super
+    NewRelic::Agent::ErrorCollector.ignore_error_filter = nil
     NewRelic::Agent::TransactionState.tl_clear_for_testing
     NewRelic::Agent.config.reset_to_defaults
   end
@@ -183,7 +184,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
   end
 
   def test_exclude_block
-    @error_collector.ignore_error_filter &wrapped_filter_proc
+    @error_collector.class.ignore_error_filter = wrapped_filter_proc
 
     @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
     @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
@@ -194,7 +195,7 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
   end
 
   def test_failure_in_exclude_block
-    @error_collector.ignore_error_filter do
+    @error_collector.class.ignore_error_filter = Proc.new do
       raise "HAHAHAHAH, error in the filter for ignoring errors!"
     end
 
@@ -205,6 +206,18 @@ class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
     assert_equal 1, errors.length
   end
 
+  def test_failure_block_assigned_with_different_instance
+    @error_collector.class.ignore_error_filter = Proc.new do |*_|
+      # meh, ignore 'em all!
+      nil
+    end
+
+    new_error_collector = NewRelic::Agent::ErrorCollector.new
+    new_error_collector.notice_error(StandardError.new("message"))
+
+    assert_empty new_error_collector.harvest!
+  end
+
   def test_obfuscates_error_messages_when_high_security_is_set
     with_config(:high_security => true) do
       @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))

data/test/new_relic/agent/event_loop_test.rb

@@ -0,0 +1,202 @@
+# 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::EventLoopTest < Minitest::Test
+  def setup
+    freeze_time
+    @loop = NewRelic::Agent::EventLoop.new
+  end
+
+  def test_fire_after
+    call_count = 0
+
+    @loop.on(:event) { call_count += 1 }
+    @loop.fire_after(3, :event)
+
+    @loop.run_once(true)
+    assert_equal(0, call_count)
+
+    advance_loop(1)
+    assert_equal(0, call_count)
+
+    advance_loop(2)
+    assert_equal(1, call_count)
+
+    advance_loop(5)
+    assert_equal(1, call_count)
+  end
+
+  def test_fire_every
+    call_count = 0
+
+    @loop.on(:event) do
+      call_count += 1
+    end
+
+    @loop.fire_every(3, :event)
+
+    @loop.run_once(true)
+    assert_equal(0, call_count)
+
+    advance_loop(2)
+    assert_equal(0, call_count)
+
+    advance_loop(1)
+    assert_equal(1, call_count)
+
+    advance_loop(4)
+    assert_equal(2, call_count)
+  end
+
+  def test_fire_resets_associated_timers
+    call_count = 0
+
+    @loop.on(:event) { call_count += 1 }
+    @loop.fire_every(10, :event)
+
+    advance_loop(5)
+    @loop.fire(:event)
+    @loop.run_once(true)
+    assert_equal(1, call_count)
+
+    advance_loop(5)
+    assert_equal(1, call_count)
+
+    advance_loop(5)
+    assert_equal(2, call_count)
+  end
+
+  def test_adjust_period_larger
+    call_count = 0
+    @loop.on(:e) { call_count += 1 }
+
+    @loop.fire_every(10, :e)
+    @loop.run_once(true)
+
+    advance_loop(9)
+    assert_equal(0, call_count)
+
+    @loop.fire_every(15, :e)
+    @loop.run_once(true)
+    assert_equal(0, call_count)
+
+    advance_loop(1)
+    assert_equal(0, call_count)
+
+    advance_loop(5)
+    assert_equal(1, call_count)
+  end
+
+  def test_adjust_period_smaller
+    call_count = 0
+    @loop.on(:e) { call_count += 1 }
+    @loop.fire_every(10, :e)
+
+    @loop.run_once(true)
+    assert_equal(0, call_count)
+
+    advance_loop(5)
+    assert_equal(0, call_count)
+
+    @loop.fire_every(2, :e)
+    @loop.run_once(true)
+    assert_equal(1, call_count)
+
+    advance_loop(1)
+    assert_equal(1, call_count)
+
+    advance_loop(1)
+    assert_equal(2, call_count)
+  end
+
+  def test_on
+    call_count = 0
+    @loop.on(:evt) do
+      call_count += 1
+    end
+    @loop.fire(:evt)
+    @loop.run_once(true)
+    assert_equal(1, call_count)
+  end
+
+  def test_on_with_payload
+    call_count = 0
+    @loop.on(:evt) do |amount|
+      call_count += amount
+    end
+    @loop.fire(:evt, 42)
+    @loop.run_once(true)
+    assert_equal(42, call_count)
+  end
+
+  def test_manual_fire_resets_timers
+    call_count = 0
+    @loop.on(:e) { call_count += 1 }
+    @loop.fire_every(4, :e)
+
+    advance_loop(3)
+    assert_equal(0, call_count)
+
+    @loop.fire(:e)
+    @loop.run_once(true)
+    assert_equal(1, call_count)
+
+    advance_loop(3)
+    assert_equal(1, call_count)
+
+    advance_loop(1)
+    assert_equal(2, call_count)
+  end
+
+  def test_exceptions_do_not_exit_loop
+    call_count = 0
+    @loop.on(:e) { raise StandardError.new }
+    @loop.on(:e) { call_count += 1 }
+    @loop.on(:e) { raise StandardError.new }
+
+    @loop.fire(:e)
+
+    @loop.run_once(true)
+    assert_equal(1, call_count)
+  end
+
+  def test_timer_period_reset_from_event
+    call_count = 0
+    @loop.on(:e           ) { call_count += 1          }
+    @loop.on(:reset_period) { @loop.fire_every(30, :e) }
+
+    @loop.fire_every( 5, :e           )
+    @loop.fire_after(31, :reset_period)
+
+    advance_loop(3)  # total time 3
+    assert_equal(0, call_count)
+
+    advance_loop(2)  # total time 5
+    assert_equal(1, call_count)
+
+    advance_loop(5)  # total time 10
+    assert_equal(2, call_count)
+
+    advance_loop(20)  # total time 30
+    assert_equal(6, call_count)
+
+    advance_loop(29)  # total time 59
+    assert_equal(6, call_count)
+
+    advance_loop(1)  # total time 60
+    assert_equal(7, call_count)
+
+    advance_loop(60)  # total time 120
+    assert_equal(9, call_count)
+  end
+
+  def advance_loop(n)
+    n.times do
+      advance_time(1)
+      @loop.run_once(true)
+    end
+  end
+end

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

@@ -39,6 +39,10 @@ class NewRelic::Agent::Instrumentation::ActiveRecordHelperTest < Minitest::Test
     assert_nil ActiveRecordHelper.metric_for_name('Model Columns')
   end
 
+  def test_metric_for_name_with_integer_returns_nil
+    assert_nil ActiveRecordHelper.metric_for_name(1)
+  end
+
   def test_rollup_metrics_for_lists_rollups
     NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
     base_metric = 'ActiveRecord/Namespace::Model/find'

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

@@ -3,242 +3,343 @@
 # 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::ControllerInstrumentationTest < Minitest::Test
-  require 'new_relic/agent/instrumentation/controller_instrumentation'
-  class TestObject
-    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
-    def public_transaction(*args); end
+module NewRelic::Agent::Instrumentation
+  class ControllerInstrumentationTest < Minitest::Test
 
-    protected
-    def protected_transaction(*args); end
+    class TestObject
+      include ControllerInstrumentation
 
-    private
-    def private_transaction(*args); end
+      def public_transaction(*args); end
 
-    add_transaction_tracer :public_transaction
-    add_transaction_tracer :protected_transaction
-    add_transaction_tracer :private_transaction
-  end
+      protected
+      def protected_transaction(*args); end
 
-  def setup
-    NewRelic::Agent.drop_buffered_data
-    @object = TestObject.new
-    @dummy_headers = { :request => 'headers' }
-    @txn_namer = NewRelic::Agent::Instrumentation::ControllerInstrumentation::TransactionNamer
-  end
+      private
+      def private_transaction(*args); end
 
-  def teardown
-    NewRelic::Agent.instance.stats_engine.clear_stats
-  end
+      add_transaction_tracer :public_transaction
+      add_transaction_tracer :protected_transaction
+      add_transaction_tracer :private_transaction
+    end
 
-  def test_apdex_recorded
-    @object.public_transaction
-    assert_metrics_recorded("Apdex")
-  end
+    class TestParent
+      include ControllerInstrumentation
 
-  def test_apdex_ignored
-    @object.stubs(:ignore_apdex?).returns(true)
-    @object.public_transaction
-    assert_metrics_not_recorded("Apdex")
-  end
+      newrelic_ignore_apdex
 
-  def test_transaction_name_calls_newrelic_metric_path
-    @object.stubs(:newrelic_metric_path).returns('some/wacky/path')
-    assert_equal('Controller/some/wacky/path', @txn_namer.name(nil, @object, :controller))
-  end
+      def foo(*args); end
 
-  def test_transaction_name_applies_category_and_path
-    assert_equal('Controller/metric/path',
-                 @txn_namer.name(nil,
-                                 @object,
-                                 :controller,
-                                 :path => 'metric/path'))
-    assert_equal('OtherTransaction/Background/metric/path',
-                 @txn_namer.name(nil,
-                                 @object,
-                                 :task,
-                                 :path => 'metric/path'))
-    assert_equal('Controller/Rack/metric/path',
-                 @txn_namer.name(nil,
-                                 @object,
-                                 :rack,
-                                 :path => 'metric/path'))
-    assert_equal('Controller/metric/path',
-                 @txn_namer.name(nil,
-                                 @object,
-                                 :uri,
-                                 :path => 'metric/path'))
-    assert_equal('Controller/Sinatra/metric/path',
-                 @txn_namer.name(nil,
-                                 @object,
-                                 :sinatra,
-                                 :path => 'metric/path'))
-    assert_equal('Blarg/metric/path',
-                 @txn_namer.name(nil,
-                                 @object,
-                                 'Blarg',
-                                 :path => 'metric/path'))
-  end
+      add_transaction_tracer :foo
+    end
 
-  def test_transaction_name_uses_class_name_if_path_not_specified
-    assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject',
-                 @txn_namer.name(nil, @object, :controller))
-  end
+    class TestChild < TestParent
+      def bar(*args); end
 
-  def test_transaction_name_applies_action_name_if_specified_and_not_path
-    assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/action',
-                 @txn_namer.name(nil,
-                                 @object,
-                                 :controller,
-                                 :name => 'action'))
-  end
+      add_transaction_tracer :bar
+    end
 
-  def test_transaction_path_name
-    result = @txn_namer.path_name(@object)
-    assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject", result)
-  end
+    def setup
+      NewRelic::Agent.drop_buffered_data
+      @object = TestObject.new
+      @dummy_headers = { :request => 'headers' }
+      @txn_namer = ControllerInstrumentation::TransactionNamer
+    end
 
-  def test_transaction_path_name_with_name
-    result = @txn_namer.path_name(@object, :name => "test")
-    assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/test", result)
-  end
+    def teardown
+      NewRelic::Agent.instance.stats_engine.clear_stats
+    end
 
-  def test_transaction_path_name_with_overridden_class_name
-    result = @txn_namer.path_name(@object, :name => "perform", :class_name => 'Resque')
-    assert_equal("Resque/perform", result)
-  end
+    def test_apdex_recorded
+      @object.public_transaction
+      assert_metrics_recorded("Apdex")
+    end
 
-  def test_add_transaction_tracer_should_not_double_instrument
-    TestObject.expects(:alias_method).never
-    TestObject.class_eval do
-      add_transaction_tracer :public_transaction
-      add_transaction_tracer :protected_transaction
-      add_transaction_tracer :private_transaction
+    def test_apdex_ignored
+      @object.stubs(:ignore_apdex?).returns(true)
+      @object.public_transaction
+      assert_metrics_not_recorded("Apdex")
     end
-    obj = TestObject.new
-  end
 
-  def test_add_transaction_tracer_defines_with_method
-    assert TestObject.method_defined? :public_transaction_with_newrelic_transaction_trace
-  end
+    def test_apdex_ignored_if_ignored_in_parent_class
+      obj = TestChild.new
 
-  def test_add_transaction_tracer_defines_without_method
-    assert TestObject.method_defined? :public_transaction_without_newrelic_transaction_trace
-  end
+      obj.foo
+      obj.bar
 
-  def test_parse_punctuation
-    ['?', '!', '='].each do |punctuation_mark|
-      result = TestObject.parse_punctuation("foo#{punctuation_mark}")
-      assert_equal ['foo', punctuation_mark], result
+      assert_metrics_not_recorded("Apdex")
     end
-  end
 
-  def test_argument_list
-    options = {:foo => :bar, :params => '{ :account_name => args[0].name }', :far => 7}
-    result = TestObject.generate_argument_list(options)
-    expected = [":far => \"7\"", ":foo => :bar", ":params => { :account_name => args[0].name }"]
-    assert_equal expected.sort, result.sort
-  end
+    def test_children_respect_parental_ignore_rules_with_only
+      parent = Class.new do
+        include ControllerInstrumentation
 
-  def test_build_method_names
-    result = TestObject.build_method_names('foo', '?')
-    expected = ["foo_with_newrelic_transaction_trace?", "foo_without_newrelic_transaction_trace?"]
-    assert_equal expected, result
-  end
+        newrelic_ignore(:only => :foo)
 
-  def test_already_added_transaction_tracer_returns_true_if_with_method_defined
-    with_method_name = 'public_transaction_with_newrelic_transaction_trace'
-    assert TestObject.already_added_transaction_tracer?(TestObject, with_method_name)
-  end
+        def foo(*args); end
+        def foo2(*args); end
+      end
 
-  # ControllerInstrumentation historically was used to instrument Rails 2
-  # controllers, and in this case is called without a block. In that case, and
-  # that case *only*, we want to try to call params on the host object to
-  # extract request params.
-  #
-  # In the more modern usage where it's called with a block we do *not* want to
-  # call params on the host object. This is important because doing so could
-  # actually crash in some cases.
-  def test_should_not_call_params_on_host_if_called_with_block
-    host_class = Class.new do
-      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-      # It's a more realistic test if the host class actually responds to params
-      def params
-        raise 'no!'
+      child = Class.new(parent) do
+        newrelic_ignore(:only => :bar)
+
+        def bar(*args); end
+        def bar2(*args); end
       end
 
-      def doit
-        perform_action_with_newrelic_trace do
-          # nothing
-        end
+      key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
+
+      assert IgnoreActions.is_filtered?(key, child, :foo )
+      assert IgnoreActions.is_filtered?(key, child, :bar )
+      refute IgnoreActions.is_filtered?(key, child, :foo2)
+      refute IgnoreActions.is_filtered?(key, child, :bar2)
+    end
+
+    def test_children_respect_parental_ignore_rules_with_except
+      parent = Class.new do
+        include ControllerInstrumentation
+
+        newrelic_ignore(:except => :foo)
+
+        def foo(*args); end
+        def foo2(*args); end
+      end
+
+      child = Class.new(parent) do
+        newrelic_ignore(:except => :bar)
+
+        def bar(*args); end
+        def bar2(*args); end
       end
+
+      key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
+
+      assert IgnoreActions.is_filtered?(key, child, :foo )
+      assert IgnoreActions.is_filtered?(key, child, :bar )
+      assert IgnoreActions.is_filtered?(key, child, :foo2)
+      assert IgnoreActions.is_filtered?(key, child, :bar2)
     end
 
-    host = host_class.new
-    host.expects(:params).never
-    host.doit
-  end
+    def test_children_respect_parental_ignore_rules_with_except_and_only
+      parent = Class.new do
+        include ControllerInstrumentation
+
+        newrelic_ignore(:only => :foo)
+
+        def foo(*args); end
+        def foo2(*args); end
+      end
 
-  def test_should_not_call_params_on_host_if_no_block_given_but_does_not_respond_to_params
-    host_class = Class.new do
-      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      child = Class.new(parent) do
+        newrelic_ignore(:except => :foo)
 
-      def doit
-        perform_action_with_newrelic_trace
+        def bar(*args); end
       end
 
-      def perform_action_without_newrelic_trace; end
+      key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
+
+      assert IgnoreActions.is_filtered?(key, child, :foo )
+      assert IgnoreActions.is_filtered?(key, child, :bar )
+      assert IgnoreActions.is_filtered?(key, child, :foo2)
     end
 
-    host = host_class.new
-    refute host.respond_to?(:params)
-    host.doit
-  end
+    def test_transaction_name_calls_newrelic_metric_path
+      @object.stubs(:newrelic_metric_path).returns('some/wacky/path')
+      assert_equal('Controller/some/wacky/path', @txn_namer.name(nil, @object, :controller))
+    end
+
+    def test_transaction_name_applies_category_and_path
+      assert_equal('Controller/metric/path',
+                   @txn_namer.name(nil,
+                                   @object,
+                                   :controller,
+                                   :path => 'metric/path'))
+      assert_equal('OtherTransaction/Background/metric/path',
+                   @txn_namer.name(nil,
+                                   @object,
+                                   :task,
+                                   :path => 'metric/path'))
+      assert_equal('Controller/Rack/metric/path',
+                   @txn_namer.name(nil,
+                                   @object,
+                                   :rack,
+                                   :path => 'metric/path'))
+      assert_equal('Controller/metric/path',
+                   @txn_namer.name(nil,
+                                   @object,
+                                   :uri,
+                                   :path => 'metric/path'))
+      assert_equal('Controller/Sinatra/metric/path',
+                   @txn_namer.name(nil,
+                                   @object,
+                                   :sinatra,
+                                   :path => 'metric/path'))
+      assert_equal('Blarg/metric/path',
+                   @txn_namer.name(nil,
+                                   @object,
+                                   'Blarg',
+                                   :path => 'metric/path'))
+    end
 
-  def test_should_call_params_on_host_if_no_block_given_and_host_responds
-    host_class = Class.new do
-      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    def test_transaction_name_uses_class_name_if_path_not_specified
+      assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject',
+                   @txn_namer.name(nil, @object, :controller))
+    end
 
-      attr_reader :params_called
+    def test_transaction_name_applies_action_name_if_specified_and_not_path
+      assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/action',
+                     @txn_namer.name(nil,
+                                     @object,
+                                     :controller,
+                                     :name => 'action'))
+    end
+
+    def test_transaction_path_name
+      result = @txn_namer.path_name(@object)
+      assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject", result)
+    end
 
-      def params
-        @params_called = true
-        {}
+    def test_transaction_path_name_with_name
+      result = @txn_namer.path_name(@object, :name => "test")
+      assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/test", result )
+    end
+
+    def test_transaction_path_name_with_overridden_class_name
+      result = @txn_namer.path_name(@object, :name => "perform", :class_name => 'Resque')
+      assert_equal("Resque/perform", result)
+    end
+
+    def test_add_transaction_tracer_should_not_double_instrument
+      TestObject.expects(:alias_method).never
+      TestObject.class_eval do
+        add_transaction_tracer :public_transaction
+        add_transaction_tracer :protected_transaction
+        add_transaction_tracer :private_transaction
       end
+      TestObject.new
+    end
 
-      def doit
-        perform_action_with_newrelic_trace
+    def test_add_transaction_tracer_defines_with_method
+      assert TestObject.method_defined? :public_transaction_with_newrelic_transaction_trace
+    end
+
+    def test_add_transaction_tracer_defines_without_method
+      assert TestObject.method_defined? :public_transaction_without_newrelic_transaction_trace
+    end
+
+    def test_parse_punctuation
+      ['?', '!', '='].each do |punctuation_mark|
+        result = TestObject.parse_punctuation("foo#{punctuation_mark}")
+        assert_equal ['foo', punctuation_mark], result
       end
+    end
 
-      def perform_action_without_newrelic_trace; end
+    def test_argument_list
+      options = {:foo => :bar, :params => '{ :account_name => args[0].name }', :far => 7}
+      result = TestObject.generate_argument_list(options)
+      expected = [":far => \"7\"", ":foo => :bar", ":params => { :account_name => args[0].name }"]
+      assert_equal expected.sort, result.sort
     end
 
-    host = host_class.new
-    host.doit
-    assert host.params_called
-  end
+    def test_build_method_names
+      result = TestObject.build_method_names('foo', '?')
+      expected = ["foo_with_newrelic_transaction_trace?", "foo_without_newrelic_transaction_trace?"]
+      assert_equal expected, result
+    end
 
-  class UserError < StandardError
-  end
+    def test_already_added_transaction_tracer_returns_true_if_with_method_defined
+      with_method_name = 'public_transaction_with_newrelic_transaction_trace'
+      assert TestObject.already_added_transaction_tracer?(TestObject, with_method_name)
+    end
 
-  def test_failure_during_starting_shouldnt_override_error_raised
-    host_class = Class.new do
-      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    # ControllerInstrumentation historically was used to instrument Rails 2
+    # controllers, and in this case is called without a block. In that case, and
+    # that case *only*, we want to try to call params on the host object to
+    # extract request params.
+    #
+    # In the more modern usage where it's called with a block we do *not* want to
+    # call params on the host object. This is important because doing so could
+    # actually crash in some cases.
+    def test_should_not_call_params_on_host_if_called_with_block
+      host_class = Class.new do
+        include ControllerInstrumentation
+
+        # It's a more realistic test if the host class actually responds to params
+        def params
+          raise 'no!'
+        end
 
-      def doit
-        perform_action_with_newrelic_trace do
-          raise UserError.new
+        def doit
+          perform_action_with_newrelic_trace do
+            # nothing
+          end
         end
       end
+
+      host = host_class.new
+      host.expects(:params).never
+      host.doit
     end
 
-    NewRelic::Agent::Transaction.stubs(:start).returns(nil)
+    def test_should_not_call_params_on_host_if_no_block_given_but_does_not_respond_to_params
+      host_class = Class.new do
+        include ControllerInstrumentation
 
-    host = host_class.new
-    assert_raises(UserError) do
+        def doit
+          perform_action_with_newrelic_trace
+        end
+
+        def perform_action_without_newrelic_trace; end
+      end
+
+      host = host_class.new
+      refute host.respond_to?(:params)
+      host.doit
+    end
+
+    def test_should_call_params_on_host_if_no_block_given_and_host_responds
+      host_class = Class.new do
+        include ControllerInstrumentation
+
+        attr_reader :params_called
+
+        def params
+          @params_called = true
+          {}
+        end
+
+        def doit
+          perform_action_with_newrelic_trace
+        end
+
+        def perform_action_without_newrelic_trace; end
+      end
+
+      host = host_class.new
       host.doit
+      assert host.params_called
+    end
+
+    class UserError < StandardError
+    end
+
+    def test_failure_during_starting_shouldnt_override_error_raised
+      host_class = Class.new do
+        include ControllerInstrumentation
+
+        def doit
+          perform_action_with_newrelic_trace do
+            raise UserError.new
+          end
+        end
+      end
+
+      NewRelic::Agent::Transaction.stubs(:start).returns(nil)
+
+      host = host_class.new
+      assert_raises(UserError) do
+        host.doit
+      end
     end
   end
 end