mmtrix_rpm 1.0.0.1

data/test/mmtrix/agent/instrumentation/active_record_subscriber_test.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+MIN_RAILS_VERSION = 4
+
+if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i >= MIN_RAILS_VERSION && !Mmtrix::LanguageSupport.using_engine?('jruby')
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'mmtrix/agent/instrumentation/active_record_subscriber'
+
+class Mmtrix::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 => 'Mmtrix::Agent::Instrumentation::ActiveRecordSubscriberTest::Order Load',
+      :sql => 'SELECT * FROM sandwiches',
+      :connection_id => @connection.object_id
+    }
+
+    @subscriber = Mmtrix::Agent::Instrumentation::ActiveRecordSubscriber.new
+
+    @stats_engine = Mmtrix::Agent.instance.stats_engine
+    @stats_engine.clear_stats
+  end
+
+  def test_records_metrics_for_simple_find
+    freeze_time
+
+    simulate_query(2)
+
+    metric_name = 'Datastore/statement/ActiveRecord/Mmtrix::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/Mmtrix::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find'
+    assert_metrics_recorded(
+      [metric_name, 'test_txn'] => { :call_count => 1, :total_call_time => 2 }
+    )
+  end
+
+  def test_records_nothing_if_tracing_disabled
+    freeze_time
+
+    Mmtrix::Agent.disable_all_tracing { simulate_query(2) }
+
+    metric_name = 'Datastore/statement/ActiveRecord/Mmtrix::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 = Mmtrix::Agent.instance.transaction_sampler
+    sampler.last_sample.root_node.each_node{|s| last_node = s }
+
+    assert_equal('Datastore/statement/ActiveRecord/Mmtrix::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find',
+                 last_node.metric_name)
+    assert_equal('SELECT * FROM sandwiches',
+                 last_node.params[:sql])
+  end
+
+  def test_creates_slow_sql_node
+    freeze_time
+
+    sampler = Mmtrix::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)
+
+    event = mock('event')
+    event.stubs(:payload).returns({ :connection_id => target_connection.object_id })
+
+    result = @subscriber.active_record_config_for_event(event)
+    assert_equal expected_config, result
+  end
+end
+
+else
+  puts "Skipping tests in #{__FILE__} because Rails >= #{MIN_RAILS_VERSION} is unavailable"
+end

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

@@ -0,0 +1,328 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+
+module Mmtrix::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
+
+      mmtrix_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_mmtrix_trace(*args)
+        @called = true
+      end
+
+      include ControllerInstrumentation
+
+      alias_method :perform_action, :perform_action_with_mmtrix_trace
+    end
+
+    def setup
+      Mmtrix::Agent.drop_buffered_data
+      @object = TestObject.new
+      @dummy_headers = { :request => 'headers' }
+      @txn_namer = ControllerInstrumentation::TransactionNamer
+    end
+
+    def teardown
+      Mmtrix::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
+        mmtrix_ignore(:only => :foo)
+      end
+
+      child = Class.new(parent) do
+        mmtrix_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
+        mmtrix_ignore(:except => :foo)
+      end
+
+      child = Class.new(parent) do
+        mmtrix_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
+        mmtrix_ignore(:only => :foo)
+      end
+
+      child = Class.new(parent) do
+        mmtrix_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
+
+        mmtrix_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
+
+        mmtrix_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_mmtrix_metric_path
+      @object.stubs(:mmtrix_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/Mmtrix::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/Mmtrix::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("Mmtrix::Agent::Instrumentation::ControllerInstrumentationTest::TestObject", result)
+    end
+
+    def test_transaction_path_name_with_name
+      result = @txn_namer.path_name(@object, :name => "test")
+      assert_equal("Mmtrix::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_mmtrix_transaction_trace
+    end
+
+    def test_add_transaction_tracer_defines_without_method
+      assert TestObject.method_defined? :public_transaction_without_mmtrix_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_mmtrix_transaction_trace?", "foo_without_mmtrix_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_mmtrix_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_mmtrix_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_mmtrix_trace do
+            raise UserError.new
+          end
+        end
+      end
+
+      Mmtrix::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_mmtrix_trace do
+            Mmtrix::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/mmtrix/agent/instrumentation/instrumentation_test.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+class Mmtrix::Agent::Instrumentation::InstrumentationTest < Minitest::Test
+  def test_load_all_instrumentation_files
+    # just checking for syntax errors and unguarded code
+    Dir.glob('mmtrix/agent/instrumentation/**/*.rb') do |f|
+      require f
+    end
+    require 'mmtrix/delayed_job_injection'
+  end
+end

data/test/mmtrix/agent/instrumentation/metric_frame_test.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+class Mmtrix::Agent::Instrumentation::MetricFrameTest < Minitest::Test
+
+  # These tests are just here to make sure that we're maintaining the required
+  # old interface for folks. Real testing of the underlying functionality
+  # should go with the Transaction methods we invoke, not these tests.
+
+  def test_recording_web_transaction
+    Mmtrix::Agent::Transaction.expects(:recording_web_transaction?)
+    Mmtrix::Agent::Instrumentation::MetricFrame.recording_web_transaction?
+  end
+
+  def test_abort_transaction
+    Mmtrix::Agent::Transaction.expects(:abort_transaction!)
+    Mmtrix::Agent::Instrumentation::MetricFrame.abort_transaction!
+  end
+end