RubyGems - newrelic_rpm - Versions diffs - 4.0.0.332 → 4.4.0.336 - Mend

newrelic_rpm 4.0.0.332 → 4.4.0.336

Files changed (917) hide show

data/test/new_relic/agent/instrumentation/active_record_subscriber_test.rb DELETED Viewed

@@ -1,210 +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.
-MIN_RAILS_VERSION = 4
-if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i >= MIN_RAILS_VERSION && !NewRelic::LanguageSupport.jruby?
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-require 'new_relic/agent/instrumentation/active_record_subscriber'
-class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Minitest::Test
-  class Order; end
-  def setup
-    @config = { :adapter => 'mysql', :host => 'server' }
-    @connection = Object.new
-    @connection.instance_variable_set(:@config, @config)
-    @params = {
-      :name => 'NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order Load',
-      :sql => 'SELECT * FROM sandwiches',
-      :connection_id => @connection.object_id
-    }
-    @subscriber = NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new
-    @stats_engine = NewRelic::Agent.instance.stats_engine
-    @stats_engine.clear_stats
-  end
-  def test_records_metrics_for_simple_find
-    freeze_time
-    in_transaction('test_txn') { simulate_query(2) }
-    metric_name = 'Datastore/statement/ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
-    assert_metrics_recorded(
-      metric_name => { :call_count => 1, :total_call_time => 2.0 }
-    )
-  end
-  def test_records_scoped_metrics
-    freeze_time
-    in_transaction('test_txn') { simulate_query(2) }
-    metric_name = 'Datastore/statement/ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
-    assert_metrics_recorded(
-      [metric_name, 'test_txn'] => { :call_count => 1, :total_call_time => 2 }
-    )
-  end
-  def test_records_datastore_instance_metric_for_supported_adapter
-    config = { :adapter => "mysql", :host => "jonan.gummy_planet", :port => 3306 }
-    @subscriber.stubs(:active_record_config).returns(config)
-    in_transaction('test_txn') { simulate_query(2) }
-    assert_metrics_recorded('Datastore/instance/MySQL/jonan.gummy_planet/3306')
-  end
-  def test_records_datastore_instance_metric_with_one_datum_missing
-    config = { :adapter => "mysql", :host => "jonan.gummy_planet", :port => "" }
-    @subscriber.stubs(:active_record_config).returns(config)
-    in_transaction('test_txn') { simulate_query(2) }
-    assert_metrics_recorded('Datastore/instance/MySQL/jonan.gummy_planet/unknown')
-    config = { :adapter => "mysql", :host => "", :port => 3306 }
-    @subscriber.stubs(:active_record_config).returns(config)
-    in_transaction('test_txn') { simulate_query(2) }
-    assert_metrics_recorded('Datastore/instance/MySQL/unknown/3306')
-  end
-  def test_does_not_record_datastore_instance_metric_for_unsupported_adapter
-    config = { :adapter => "JonanDB", :host => "jonan.gummy_planet" }
-    @subscriber.stubs(:active_record_config).returns(config)
-    in_transaction('test_txn') { simulate_query(2) }
-    assert_metrics_not_recorded('Datastore/instance/JonanDB/jonan.gummy_planet/default')
-  end
-  def test_does_not_record_datastore_instance_metric_if_disabled
-    with_config('datastore_tracer.instance_reporting.enabled' => false) do
-      config = { :host => "jonan.gummy_planet" }
-      @subscriber.stubs(:active_record_config).returns(config)
-      in_transaction('test_txn') { simulate_query(2) }
-      assert_metrics_not_recorded('Datastore/instance/ActiveRecord/jonan.gummy_planet/default')
-    end
-  end
-  def test_does_not_record_datastore_instance_metric_if_both_are_empty
-    config = { :adapter => "", :host => "" }
-    @subscriber.stubs(:active_record_config).returns(config)
-    in_transaction('test_txn') { simulate_query(2) }
-    assert_metrics_not_recorded('Datastore/instance/unknown/unknown')
-  end
-  def test_does_not_record_database_name_if_disabled
-    config = { :host => "jonan.gummy_planet", :database => "pizza_cube" }
-    @subscriber.stubs(:active_record_config).returns(config)
-    with_config('datastore_tracer.database_name_reporting.enabled' => false) do
-      in_transaction { simulate_query(2) }
-    end
-    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-    node = find_node_with_name_matching sample, /Datastore\//
-    refute node.params.key?(:database_name)
-  end
-  def test_records_unknown_unknown_when_error_gathering_instance_data
-    NewRelic::Agent::Instrumentation::ActiveRecordHelper::InstanceIdentification.stubs(:postgres_unix_domain_socket_case?).raises StandardError.new
-    NewRelic::Agent::Instrumentation::ActiveRecordHelper::InstanceIdentification.stubs(:mysql_default_case?).raises StandardError.new
-    config = {:adapter => 'mysql', :host => "127.0.0.1"}
-    @subscriber.stubs(:active_record_config).returns(config)
-    in_transaction('test_txn') { simulate_query(2) }
-    assert_metrics_recorded("Datastore/instance/MySQL/unknown/unknown")
-  end
-  def test_records_nothing_if_tracing_disabled
-    freeze_time
-    in_transaction('test_txn') do
-      NewRelic::Agent.disable_all_tracing { simulate_query(2) }
-    end
-    metric_name = 'Datastore/statement/ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
-    assert_metrics_not_recorded([metric_name])
-  end
-  def test_records_rollup_metrics
-    freeze_time
-    in_web_transaction { simulate_query(2) }
-    assert_metrics_recorded(
-      'Datastore/operation/ActiveRecord/find' => { :call_count => 1, :total_call_time => 2 },
-      'Datastore/allWeb' => { :call_count => 1, :total_call_time => 2 },
-      'Datastore/all' => { :call_count => 1, :total_call_time => 2 }
-    )
-  end
-  def test_creates_txn_node
-    freeze_time
-    in_transaction do
-      simulate_query(2)
-    end
-    last_node = nil
-    sampler = NewRelic::Agent.instance.transaction_sampler
-    sampler.last_sample.root_node.each_node{|s| last_node = s }
-    assert_equal('Datastore/statement/ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find',
-                 last_node.metric_name)
-    assert_equal('SELECT * FROM sandwiches',
-                 last_node.params[:sql].sql)
-  end
-  def test_creates_slow_sql_node
-    freeze_time
-    sampler = NewRelic::Agent.instance.sql_sampler
-    sql = nil
-    in_transaction do
-      simulate_query(2)
-      sql = sampler.tl_transaction_data.sql_data[0].sql
-    end
-    assert_equal 'SELECT * FROM sandwiches', sql
-  end
-  def test_should_not_raise_due_to_an_exception_during_instrumentation_callback
-    @subscriber.stubs(:record_metrics).raises(StandardError)
-    simulate_query
-  end
-  def simulate_query(duration=nil)
-    @subscriber.start('sql.active_record', :id, @params)
-    advance_time(duration) if duration
-    @subscriber.finish('sql.active_record', :id, @params)
-  end
-  def test_active_record_config_for_event
-    target_connection = ActiveRecord::Base.connection_handler.connection_pool_list.first.connections.first
-    expected_config = target_connection.instance_variable_get(:@config)
-    payload = { :connection_id => target_connection.object_id }
-    result = @subscriber.active_record_config(payload)
-    assert_equal expected_config, result
-  end
-end
-else
-  puts "Skipping tests in #{__FILE__} because Rails >= #{MIN_RAILS_VERSION} is unavailable"
-end

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

@@ -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 DELETED Viewed

@@ -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