newrelic_rpm 4.1.0.333 → 4.2.0.334

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

@@ -1,328 +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__), '..', '..', '..', 'test_helper'))
-
-module NewRelic::Agent::Instrumentation
-  class ControllerInstrumentationTest < Minitest::Test
-
-    class TestObject
-      include ControllerInstrumentation
-
-      def public_transaction(*args); end
-
-      protected
-      def protected_transaction(*args); end
-
-      private
-      def private_transaction(*args); end
-
-      add_transaction_tracer :public_transaction
-      add_transaction_tracer :protected_transaction
-      add_transaction_tracer :private_transaction
-    end
-
-    class TestParent
-      include ControllerInstrumentation
-
-      newrelic_ignore_apdex
-
-      def foo(*args); end
-
-      add_transaction_tracer :foo
-    end
-
-    class TestChild < TestParent
-      def bar(*args); end
-
-      add_transaction_tracer :bar
-    end
-
-    class TestNonBlockObject
-      attr_reader :called
-
-      def perform_action_without_newrelic_trace(*args)
-        @called = true
-      end
-
-      include ControllerInstrumentation
-
-      alias_method :perform_action, :perform_action_with_newrelic_trace
-    end
-
-    def setup
-      NewRelic::Agent.drop_buffered_data
-      @object = TestObject.new
-      @dummy_headers = { :request => 'headers' }
-      @txn_namer = ControllerInstrumentation::TransactionNamer
-    end
-
-    def teardown
-      NewRelic::Agent.instance.stats_engine.clear_stats
-    end
-
-    def test_apdex_recorded
-      @object.public_transaction
-      assert_metrics_recorded("Apdex")
-    end
-
-    def test_apdex_ignored
-      @object.stubs(:ignore_apdex?).returns(true)
-      @object.public_transaction
-      assert_metrics_not_recorded("Apdex")
-    end
-
-    def test_apdex_ignored_if_ignored_in_parent_class
-      obj = TestChild.new
-
-      obj.foo
-      obj.bar
-
-      assert_metrics_not_recorded("Apdex")
-    end
-
-    def test_children_respect_parental_ignore_rules_with_only
-      parent = Class.new do
-        include ControllerInstrumentation
-        newrelic_ignore(:only => :foo)
-      end
-
-      child = Class.new(parent) do
-        newrelic_ignore(:only => :bar)
-      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)
-      end
-
-      child = Class.new(parent) do
-        newrelic_ignore(:except => :bar)
-      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
-
-    def test_children_respect_parental_ignore_rules_with_except_and_only
-      parent = Class.new do
-        include ControllerInstrumentation
-        newrelic_ignore(:only => :foo)
-      end
-
-      child = Class.new(parent) do
-        newrelic_ignore(:except => :foo)
-      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
-
-    def test_ignore_allows_strings
-      controller = Class.new do
-        include ControllerInstrumentation
-
-        newrelic_ignore(:only => "foo")
-      end
-
-      key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
-      assert IgnoreActions.is_filtered?(key, controller, :foo)
-    end
-
-    def test_ignore_allows_mixed_strings_and_symbols
-      controller = Class.new do
-        include ControllerInstrumentation
-
-        newrelic_ignore(:only => ["foo", :bar])
-      end
-
-      key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
-      assert IgnoreActions.is_filtered?(key, controller, :foo)
-      assert IgnoreActions.is_filtered?(key, controller, :bar)
-    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_for(nil, @object, :controller))
-    end
-
-    def test_transaction_name_applies_category_and_path
-      assert_equal('Controller/metric/path',
-                   @txn_namer.name_for(nil,
-                                   @object,
-                                   :controller,
-                                   :path => 'metric/path'))
-      assert_equal('OtherTransaction/Background/metric/path',
-                   @txn_namer.name_for(nil,
-                                   @object,
-                                   :task,
-                                   :path => 'metric/path'))
-      assert_equal('Controller/Rack/metric/path',
-                   @txn_namer.name_for(nil,
-                                   @object,
-                                   :rack,
-                                   :path => 'metric/path'))
-      assert_equal('Controller/metric/path',
-                   @txn_namer.name_for(nil,
-                                   @object,
-                                   :uri,
-                                   :path => 'metric/path'))
-      assert_equal('Controller/Sinatra/metric/path',
-                   @txn_namer.name_for(nil,
-                                   @object,
-                                   :sinatra,
-                                   :path => 'metric/path'))
-      assert_equal('Blarg/metric/path',
-                   @txn_namer.name_for(nil,
-                                   @object,
-                                   'Blarg',
-                                   :path => 'metric/path'))
-    end
-
-    def test_transaction_name_uses_class_name_if_path_not_specified
-      assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject',
-                   @txn_namer.name_for(nil, @object, :controller))
-    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_for(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 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 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 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_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
-
-    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_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
-            # nothing
-          end
-        end
-      end
-
-      host = host_class.new
-      host.expects(:params).never
-      host.doit
-    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
-
-    def test_should_not_set_request_path
-      clazz = Class.new do
-        include ControllerInstrumentation
-
-        def doit
-          perform_action_with_newrelic_trace do
-            NewRelic::Agent::TransactionState.tl_get.current_transaction.request_path
-          end
-        end
-      end
-
-      request_path = clazz.new.doit
-      assert_nil request_path
-    end
-  end
-end

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

@@ -1,23 +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__),'..','..','..','test_helper'))
-require 'new_relic/agent/instrumentation/delayed_job_instrumentation'
-
-module NewRelic::Agent::Instrumentation
-  class DelayedJobInstrumentationTest < Minitest::Test
-
-    class DummyPayload
-      include NewRelic::Agent::Instrumentation::DelayedJob::Naming
-      attr_accessor :object
-    end
-
-    def test_legacy_performable_method
-      payload_string = DummyPayload.new.tap { |dp| dp.object = 'LOAD;Foo' }
-      payload_fixnum = DummyPayload.new.tap { |dp| dp.object = 123 }
-      assert DummyPayload.new.send(:legacy_performable_method?, payload_string)
-      refute DummyPayload.new.send(:legacy_performable_method?, payload_fixnum)
-    end
-  end
-end

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

@@ -1,169 +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__),'..','..','..','test_helper'))
-require 'new_relic/agent/instrumentation/active_record_helper'
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module ActiveRecordHelper
-        class InstanceIdentificationTest < Minitest::Test
-
-          def test_for_constructs_id_with_configured_host_and_port
-            config = {
-              :host => "jonan.local",
-              :port => 42
-            }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "jonan.local", host
-            assert_equal "42", ppid
-          end
-
-          def test_for_constructs_id_with_unspecified_configuration
-            config = {}
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "localhost", host
-            assert_equal "default", ppid
-          end
-
-          def test_for_constructs_id_with_weird_configs
-            config = {
-              :host => "",
-              :port => ""
-            }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "unknown", host
-            assert_equal "unknown", ppid
-          end
-
-          def test_for_constructs_id_with_configured_host_without_port
-            config = { :host => "jonan.gummy_planet" }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "jonan.gummy_planet", host
-            assert_equal "default", ppid
-          end
-
-          def test_for_constructs_id_with_port_without_host
-            config = { :port => 1337 }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "localhost", host
-            assert_equal "1337", ppid
-          end
-
-          def test_for_constructs_id_with_default_port
-            config = {
-              :adapter => "mysql",
-              :host => "jonan.gummy_planet"
-            }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "jonan.gummy_planet", host
-            assert_equal "3306", ppid
-          end
-
-          def test_for_constructs_id_with_postgres_directory
-            config = {
-              :adapter => "postgresql",
-              :host => "/tmp"
-            }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "localhost", host
-            assert_equal "default", ppid
-          end
-
-          def test_for_constructs_id_with_mysql_socket
-            %w[ mysql mysql2 jdbcmysql ].each do |adapter|
-              config = {
-                :adapter => adapter,
-                :socket => "/var/run/mysqld.sock"
-              }
-
-              host = InstanceIdentification.host(config)
-              ppid = InstanceIdentification.port_path_or_id(config)
-
-              assert_equal "localhost", host
-              assert_equal "/var/run/mysqld.sock", ppid
-            end
-          end
-
-          def test_supports_supported_adapters
-            %w(mysql mysql2 postgresql).each do |adapter|
-              assert InstanceIdentification.supported_adapter?({:adapter => adapter })
-            end
-          end
-
-          SUPPORTED_PRODUCTS = ["Postgres", "MySQL"]
-
-          load_cross_agent_test('datastores/datastore_instances').each do |test|
-            next unless SUPPORTED_PRODUCTS.include?(test['product'])
-
-            define_method :"test_#{test['name'].tr(' ', '_')}" do
-              NewRelic::Agent.drop_buffered_data
-              NewRelic::Agent::Hostname.stubs(:get).returns(test['system_hostname'])
-
-              in_transaction do
-                config = convert_test_case_to_config test
-                product, operation, collection = ActiveRecordHelper.product_operation_collection_for "Blog Find", nil , config[:adapter]
-                host = ActiveRecordHelper::InstanceIdentification.host(config)
-                port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(config)
-
-                segment = NewRelic::Agent::Transaction.start_datastore_segment product, operation, collection, host, port_path_or_id
-                segment.finish
-              end
-
-              assert_metrics_recorded test['expected_instance_metric']
-            end
-          end
-
-          CONFIG_NAMES = {
-            "db_hostname" => :host,
-            "unix_socket" => :socket,
-            "port" => :port,
-            "product" => :adapter
-          }
-
-          def convert_test_case_to_config test_case
-            config = test_case.inject({}) do |memo, (k,v)|
-              if config_key = CONFIG_NAMES[k]
-                memo[config_key] = v
-              end
-              memo
-            end
-            convert_product_to_adapter config
-            config
-          end
-
-          PRODUCT_TO_ADAPTER_NAMES = {
-            "Postgres" => "postgresql",
-            "MySQL" => "mysql",
-            "SQLite" => "sqlite3"
-          }
-
-          def convert_product_to_adapter config
-            config[:adapter] = PRODUCT_TO_ADAPTER_NAMES[config[:adapter]]
-          end
-        end
-      end
-    end
-  end
-end