mmtrix_rpm 1.0.0.1

data/test/mmtrix/agent/inbound_request_monitor_test.rb

@@ -0,0 +1,49 @@
+# 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'))
+require 'mmtrix/agent/inbound_request_monitor'
+
+module Mmtrix::Agent
+  class InboundRequestMonitorTest < Minitest::Test
+
+    ENCODING_KEY_NOOP         = "\0"
+
+    def setup
+      @events  = Mmtrix::Agent::EventListener.new
+      @monitor = Mmtrix::Agent::InboundRequestMonitor.new(@events)
+
+      @config = { :encoding_key => ENCODING_KEY_NOOP }
+      Mmtrix::Agent.config.add_config_for_testing(@config)
+
+      class << @monitor
+        define_method(:on_finished_configuring) do |*_|
+        end
+      end
+
+      @events.notify(:finished_configuring)
+    end
+
+    def teardown
+      Mmtrix::Agent.config.remove_config(@config)
+    end
+
+    def test_deserialize
+      payload = @monitor.obfuscator.obfuscate("[1,2,3]")
+      assert_equal [1, 2, 3], @monitor.deserialize_header(payload, "the_key")
+    end
+
+    def test_deserialize_nonsense
+      expects_logging(:debug, includes("the_key"))
+      assert_nil @monitor.deserialize_header("asdf", "the_key")
+    end
+
+    def test_deserialize_with_invalid_json
+      payload = @monitor.obfuscator.obfuscate("[1,2,3")
+
+      expects_logging(:debug, includes("the_key"))
+      assert_nil @monitor.deserialize_header(payload, "the_key")
+    end
+  end
+end

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

@@ -0,0 +1,299 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+if defined?(::Rails)
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'mmtrix/agent/instrumentation/action_controller_subscriber'
+
+class Mmtrix::Agent::Instrumentation::ActionControllerSubscriberTest < Minitest::Test
+  class TestController
+    include Mmtrix::Agent::Instrumentation::ControllerInstrumentation
+
+    def self.controller_path
+      'test'
+    end
+
+    def action_name
+      'test'
+    end
+
+    mmtrix_ignore :only => :ignored_action
+    mmtrix_ignore_apdex :only => :ignored_apdex
+    mmtrix_ignore_enduser :only => :ignored_enduser
+  end
+
+  def setup
+    freeze_time
+    @subscriber = Mmtrix::Agent::Instrumentation::ActionControllerSubscriber.new
+    Mmtrix::Agent.drop_buffered_data
+    @entry_payload = {
+      :controller => TestController.to_s,
+      :action => 'index',
+      :format => :html,
+      :method => 'GET',
+      :path => '/tests',
+      :params => { :controller => 'test_controller', :action => 'index' },
+    }
+    @exit_payload = @entry_payload.merge(:status => 200, :view_runtime => 5.0,
+                                         :db_runtime => 0.5 )
+    @stats_engine = Mmtrix::Agent.instance.stats_engine
+    @stats_engine.clear_stats
+    Mmtrix::Agent.manual_start
+    Mmtrix::Agent::TransactionState.tl_clear_for_testing
+  end
+
+  def teardown
+    Mmtrix::Agent.shutdown
+    @stats_engine.clear_stats
+  end
+
+  def test_record_controller_metrics
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    advance_time(2)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    expected_values = { :call_count => 1, :total_call_time => 2.0 }
+    assert_metrics_recorded(
+      'Controller/test/index' => expected_values,
+      'HttpDispatcher' => expected_values
+    )
+  end
+
+  def test_record_apdex_metrics
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    advance_time(1.5)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    expected_values = { :apdex_f => 0, :apdex_t => 1, :apdex_s => 0 }
+    assert_metrics_recorded(
+      'Apdex/test/index' => expected_values,
+      'Apdex' => expected_values
+    )
+  end
+
+  def test_record_apdex_metrics_with_error
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    advance_time(1.5)
+
+    error = StandardError.new("boo")
+    @exit_payload[:exception] = error
+    Mmtrix::Agent.notice_error(error)
+
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    expected_values = { :apdex_f => 1, :apdex_t => 0, :apdex_s => 0 }
+    assert_metrics_recorded(
+      'Apdex/test/index' => expected_values,
+      'Apdex' => expected_values
+    )
+  end
+
+  def test_records_scoped_metrics_for_evented_child_txn
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.start('process_action.action_controller', :id, @entry_payload \
+                        .merge(:action => 'child', :path => '/child'))
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload \
+                         .merge(:action => 'child', :path => '/child'))
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_metrics_recorded(
+      ['Nested/Controller/test/child', 'Controller/test/child'] => { :call_count => 1 }
+    )
+  end
+
+  def test_records_scoped_metrics_for_traced_child_txn
+    controller = TestController.new
+    controller.perform_action_with_mmtrix_trace(:category => :controller,
+                                                  :name => 'index',
+                                                  :class_name => 'test') do
+      @subscriber.start('process_action.action_controller', :id, @entry_payload \
+                          .merge(:action => 'child', :path => '/child'))
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload \
+                           .merge(:action => 'child', :path => '/child'))
+    end
+
+    assert_metrics_recorded(
+      ['Nested/Controller/test/child', 'Controller/test/child'] => { :call_count => 1 }
+    )
+  end
+
+  def test_sets_default_transaction_name_on_start
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    assert_equal 'Controller/test/index', Mmtrix::Agent::Transaction.tl_current.best_name
+  ensure
+    @subscriber.finish('process_action.action_controller', :id, @entry_payload)
+  end
+
+  def test_sets_default_transaction_keeps_name_through_stop
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    txn = Mmtrix::Agent::Transaction.tl_current
+    @subscriber.finish('process_action.action_controller', :id, @entry_payload)
+    assert_equal 'Controller/test/index', txn.best_name
+  end
+
+  def test_sets_transaction_name
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    Mmtrix::Agent.set_transaction_name('something/else')
+    assert_equal 'Controller/something/else', Mmtrix::Agent::Transaction.tl_current.best_name
+  ensure
+    @subscriber.finish('process_action.action_controller', :id, @entry_payload)
+  end
+
+  def test_sets_transaction_name_holds_through_stop
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    txn = Mmtrix::Agent::Transaction.tl_current
+    Mmtrix::Agent.set_transaction_name('something/else')
+    @subscriber.finish('process_action.action_controller', :id, @entry_payload)
+    assert_equal 'Controller/something/else', txn.best_name
+  end
+
+  def test_record_nothing_for_ignored_action
+    @entry_payload[:action] = 'ignored_action'
+    @exit_payload[:action] = 'ignored_action'
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_metrics_not_recorded([
+      'Controller/test/ignored_action',
+      'Apdex/test/ignored_action',
+      'Apdex',
+      'HttpDispatcher'
+    ])
+  end
+
+  def test_record_no_apdex_metric_for_ignored_apdex_action
+    @entry_payload[:action] = 'ignored_apdex'
+    @exit_payload[:action] = 'ignored_apdex'
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_metrics_recorded(['Controller/test/ignored_apdex', 'HttpDispatcher'])
+    assert_metrics_not_recorded(['Apdex', 'Apdex/test/ignored_apdex'])
+  end
+
+  def test_ignore_end_user
+    @entry_payload[:action] = 'ignored_enduser'
+    @exit_payload[:action] = 'ignored_enduser'
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    txn = Mmtrix::Agent::Transaction.tl_current
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert txn.ignore_enduser?
+  end
+
+  def test_record_busy_time
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    advance_time(1)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    Mmtrix::Agent::BusyCalculator.harvest_busy
+
+    assert_metrics_recorded('Instance/Busy' => { :call_count => 1, :total_call_time => 1.0 })
+  end
+
+  def test_creates_transaction
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_equal('Controller/test/index',
+                 Mmtrix::Agent.instance.transaction_sampler \
+                   .last_sample.transaction_name)
+    assert_equal('Controller/test/index',
+                 Mmtrix::Agent.instance.transaction_sampler \
+                   .last_sample.root_node.called_nodes[0].metric_name)
+  end
+
+  def test_applies_txn_name_rules
+    rule_specs = [{'match_expression' => 'test', 'replacement' => 'taste'}]
+
+    with_transaction_renaming_rules(rule_specs) do
+      @subscriber.start('process_action.action_controller', :id, @entry_payload)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    end
+
+    assert_metrics_recorded(['Controller/taste/index'])
+    assert_metrics_not_recorded(['Controller/test/index'])
+  end
+
+  def test_record_queue_time_metrics
+    app = lambda do |env|
+      @subscriber.start('process_action.action_controller', :id, @entry_payload)
+      advance_time(2)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    end
+
+    t0 = Time.now
+    env = { 'HTTP_X_REQUEST_START' => (t0 - 5).to_f.to_s }
+    ::Mmtrix::Rack::AgentHooks.new(app).call(env)
+
+    assert_metrics_recorded(
+      'WebFrontend/QueueTime' => {
+        :call_count => 1,
+        :total_call_time => 5.0
+      }
+    )
+  end
+
+  def test_dont_record_queue_time_if_no_header
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    assert_metrics_not_recorded('WebFrontend/QueueTime')
+  end
+
+  def test_dont_record_queue_time_in_nested_transaction
+    app = lambda do |env|
+      @subscriber.start('process_action.action_controller',  :id, @entry_payload)
+      @subscriber.start('process_action.action_controller',  :id, @entry_payload)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    end
+
+    t0 = Time.now
+    env = { 'HTTP_X_REQUEST_START' => (t0 - 5).to_f.to_s }
+    ::Mmtrix::Rack::AgentHooks.new(app).call(env)
+
+    assert_metrics_recorded(
+      'WebFrontend/QueueTime' => {
+        :call_count => 1,
+        :total_call_time => 5.0
+      }
+    )
+  end
+
+  def test_records_request_params_in_txn
+    with_config(:capture_params => true) do
+      @entry_payload[:params]['number'] = '666'
+      @subscriber.start('process_action.action_controller', :id, @entry_payload)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    end
+
+    sample = Mmtrix::Agent.instance.transaction_sampler.last_sample
+    assert_equal('666', attributes_for(sample, :agent)['request.parameters.number'])
+  end
+
+  def test_records_filtered_request_params_in_txn
+    with_config(:capture_params => true) do
+      @entry_payload[:params]['password'] = 'secret'
+      @subscriber.start('process_action.action_controller', :id, @entry_payload)
+      @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+    end
+
+    sample = Mmtrix::Agent.instance.transaction_sampler.last_sample
+    assert_equal('[FILTERED]', attributes_for(sample, :agent)['request.parameters.password'])
+  end
+
+  def test_records_custom_parameters_in_txn
+    @subscriber.start('process_action.action_controller', :id, @entry_payload)
+    Mmtrix::Agent.add_custom_attributes('number' => '666')
+    @subscriber.finish('process_action.action_controller', :id, @exit_payload)
+
+    sample = Mmtrix::Agent.instance.transaction_sampler.last_sample
+    assert_equal('666', attributes_for(sample, :custom)['number'])
+  end
+end if ::Rails::VERSION::MAJOR.to_i >= 4
+
+else
+  puts "Skipping tests in #{__FILE__} because Rails is unavailable"
+end

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

@@ -0,0 +1,239 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+if defined?(::Rails)
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'mmtrix/agent/instrumentation/action_view_subscriber'
+
+class Mmtrix::Agent::Instrumentation::ActionViewSubscriberTest < Minitest::Test
+  def setup
+    @subscriber = Mmtrix::Agent::Instrumentation::ActionViewSubscriber.new
+    @stats_engine = Mmtrix::Agent.instance.stats_engine
+  end
+
+  def teardown
+    Mmtrix::Agent.instance.stats_engine.clear_stats
+  end
+
+  def test_records_metrics_for_simple_template
+    params = { :identifier => '/root/app/views/model/index.html.erb' }
+
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_template.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => 'model/index')
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => 'model/index')
+    @subscriber.finish('render_template.action_view', :id, params)
+
+    expected = { :call_count => 1, :total_call_time => 2.0 }
+    assert_metrics_recorded('View/model/index.html.erb/Rendering' => expected)
+  end
+
+  def test_records_metrics_for_simple_file
+    params = { :identifier => '/root/something.txt' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_template.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => nil)
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => nil)
+    @subscriber.finish('render_template.action_view', :id, params)
+
+    expected = { :call_count => 1, :total_call_time => 2.0 }
+    assert_metrics_recorded('View/file/Rendering' => expected)
+  end
+
+  def test_records_metrics_for_simple_inline
+    params = { :identifier => 'inline template' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_template.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => nil)
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => nil)
+    @subscriber.finish('render_template.action_view', :id, params)
+
+    expected = { :call_count => 1, :total_call_time => 2.0 }
+    assert_metrics_recorded('View/inline template/Rendering' => expected)
+  end
+
+  def test_records_metrics_for_simple_text
+    params = { :identifier => 'text template' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0 + 2)
+
+    @subscriber.start('render_template.action_view', :id, params)
+    @subscriber.finish('render_template.action_view', :id, params)
+
+    expected = { :call_count => 1, :total_call_time => 2.0 }
+    assert_metrics_recorded('View/text template/Rendering' => expected)
+  end
+
+  def test_records_metrics_for_simple_partial
+    params = { :identifier => '/root/app/views/model/_form.html.erb' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_partial.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => 'model/_form')
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => 'model/_form')
+    @subscriber.finish('render_partial.action_view', :id, params)
+
+    expected = { :call_count => 1, :total_call_time => 2.0 }
+    assert_metrics_recorded('View/model/_form.html.erb/Partial' => expected)
+  end
+
+  def test_records_metrics_for_simple_collection
+    params = { :identifier => '/root/app/views/model/_user.html.erb' }
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0, t0 + 2, t0 + 2)
+
+    @subscriber.start('render_collection.action_view', :id, params)
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => 'model/_user')
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => 'model/_user')
+    @subscriber.finish('render_collection.action_view', :id, params)
+
+    expected = { :call_count => 1, :total_call_time => 2.0 }
+    assert_metrics_recorded('View/model/_user.html.erb/Partial' => expected)
+  end
+
+  def test_records_metrics_for_layout
+    t0 = Time.now
+    Time.stubs(:now).returns(t0, t0 + 2)
+
+    @subscriber.start('!render_template.action_view', :id,
+                      :virtual_path => 'layouts/application')
+    @subscriber.finish('!render_template.action_view', :id,
+                       :virtual_path => 'layouts/application')
+
+    expected = { :call_count => 1, :total_call_time => 2.0 }
+    assert_metrics_recorded('View/layouts/application/Rendering' => expected)
+  end
+
+  def test_records_scoped_metric
+    params = { :identifier => '/root/app/views/model/index.html.erb' }
+
+    in_transaction('test_txn') do
+      @subscriber.start('render_template.action_view', :id, params)
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/index')
+      @subscriber.finish('!render_template.action_view', :id,
+                         :virtual_path => 'model/index')
+      @subscriber.finish('render_template.action_view', :id, params)
+    end
+
+    expected = { :call_count => 1 }
+    assert_metrics_recorded(
+      ['View/model/index.html.erb/Rendering', 'test_txn'] => expected
+    )
+  end
+
+  def test_records_nothing_if_tracing_disabled
+    params = { :identifier => '/root/app/views/model/_user.html.erb' }
+
+    Mmtrix::Agent.disable_all_tracing do
+      @subscriber.start('render_collection.action_view', :id, params)
+      @subscriber.finish('render_collection.action_view', :id, params)
+    end
+
+    assert_metrics_not_recorded('View/model/_user.html.erb/Partial')
+  end
+
+  def test_creates_txn_node_for_simple_render
+    params = { :identifier => '/root/app/views/model/index.html.erb' }
+
+    in_transaction do
+      @subscriber.start('render_template.action_view', :id, params)
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/index')
+      @subscriber.finish('!render_template.action_view', :id,
+                         :virtual_path => 'model/index')
+      @subscriber.finish('render_template.action_view', :id, params)
+    end
+
+    last_node = nil
+    sampler = Mmtrix::Agent.instance.transaction_sampler
+    sampler.last_sample.root_node.each_node{|s| last_node = s }
+    Mmtrix::Agent.shutdown
+
+    assert_equal('View/model/index.html.erb/Rendering',
+                 last_node.metric_name)
+  end
+
+  def test_creates_nested_partial_node_within_render_node
+    in_transaction do
+      @subscriber.start('render_template.action_view', :id,
+                        :identifier => 'model/index.html.erb')
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/index')
+      @subscriber.start('render_partial.action_view', :id,
+                        :identifier => '/root/app/views/model/_list.html.erb')
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('!render_template.action_view', :id,
+                         :virtual_path => 'model/_list')
+      @subscriber.finish('render_partial.action_view', :id,
+                         :identifier => '/root/app/views/model/_list.html.erb')
+      @subscriber.finish('!render_template.action_view', :id,
+                           :virtual_path => 'model/index')
+      @subscriber.finish('render_template.action_view', :id,
+                         :identifier => 'model/index.html.erb')
+    end
+
+    sampler = Mmtrix::Agent.instance.transaction_sampler
+    template_node = sampler.last_sample.root_node.called_nodes[0].called_nodes[0]
+    partial_node = template_node.called_nodes[0]
+
+    assert_equal('View/model/index.html.erb/Rendering',
+                 template_node.metric_name)
+    assert_equal('View/model/_list.html.erb/Partial',
+                 partial_node.metric_name)
+  end
+
+  def test_creates_nodes_for_each_in_a_collection_event
+    in_transaction do
+      @subscriber.start('render_collection.action_view', :id,
+                        :identifier => '/root/app/views/model/_list.html.erb',
+                        :count => 3)
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.start('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('!render_template.action_view', :id,
+                        :virtual_path => 'model/_list')
+      @subscriber.finish('render_collection.action_view', :id,
+                         :identifier => '/root/app/views/model/_list.html.erb',
+                         :count => 3)
+    end
+
+    sampler = Mmtrix::Agent.instance.transaction_sampler
+    partial_nodes = sampler.last_sample.root_node.called_nodes[0].called_nodes
+
+    assert_equal 3, partial_nodes.size
+    assert_equal('View/model/_list.html.erb/Partial',
+                 partial_nodes[0].metric_name)
+  end
+end if ::Rails::VERSION::MAJOR.to_i >= 4
+
+else
+  puts "Skipping tests in #{__FILE__} because Rails is unavailable"
+end

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

@@ -0,0 +1,20 @@
+# 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'))
+require 'mmtrix/agent/instrumentation/active_job'
+
+module Mmtrix::Agent::Instrumentation
+  class ActiveJobHelperTest < Minitest::Test
+    def test_rails_formatted_adapters_get_shortened
+      name = ActiveJobHelper.clean_adapter_name("ActiveJob::QueueAdapters::InlineAdapter")
+      assert_equal "ActiveJob::Inline", name
+    end
+
+    def test_unexpected_name_format
+      name = ActiveJobHelper.clean_adapter_name("Not::AnExpected::Adapter")
+      assert_equal "Not::AnExpected::Adapter", name
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# 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'))
+require 'mmtrix/agent/instrumentation/active_record_helper'
+
+module Mmtrix::Agent::Instrumentation
+  class ActiveRecordHelperTest < Minitest::Test
+
+    def test_metrics_for_find
+      metrics = ActiveRecordHelper.metrics_for('Namespace::Model Load', nil, nil)
+      expected = expected_statement_metrics("find", "Namespace::Model/find")
+      assert_equal(expected, metrics)
+    end
+
+    def test_metrics_for_destroy
+      metrics = ActiveRecordHelper.metrics_for('Model Destroy', nil, nil)
+      expected = expected_statement_metrics("destroy", "Model/destroy")
+      assert_equal(expected, metrics)
+    end
+
+    def test_metrics_for_create
+      metrics = ActiveRecordHelper.metrics_for('Model Create', nil, nil)
+      expected = expected_statement_metrics("create", "Model/create")
+      assert_equal(expected, metrics)
+    end
+
+    def test_metrics_for_update
+      metrics = ActiveRecordHelper.metrics_for('Model Update', nil, nil)
+      expected = expected_statement_metrics("update", "Model/update")
+      assert_equal(expected, metrics)
+    end
+
+    def test_metric_for_name_columns
+      metrics = ActiveRecordHelper.metrics_for('Model Columns', nil, nil)
+      expected = expected_statement_metrics("columns", "Model/columns")
+      assert_equal(expected, metrics)
+    end
+
+    def test_metric_with_product_name_from_adapter
+      metrics = ActiveRecordHelper.metrics_for('Model Load', nil, "mysql")
+      expected = expected_statement_metrics("find", "Model/find", "MySQL")
+      assert_equal(expected, metrics)
+    end
+
+    def test_metrics_from_sql
+      metrics = ActiveRecordHelper.metrics_for('invalid', "SELECT * FROM boo", nil)
+      expected = expected_operation_metrics("select")
+      assert_equal(expected, metrics)
+    end
+
+    def test_metric_for_name_with_integer_returns_nil
+      metrics = ActiveRecordHelper.metrics_for(1, '', nil)
+      expected = expected_operation_metrics("other")
+      assert_equal(expected, metrics)
+    end
+
+    def test_rollup_metrics_for_is_deprecated
+      Mmtrix::Agent::Deprecator.expects(:deprecate)
+      result = ActiveRecordHelper.rollup_metrics_for("boo")
+      assert_equal ["Datastore/allOther", "Datastore/all"], result
+    end
+
+    def expected_statement_metrics(operation, statement, product = "ActiveRecord")
+      ["Datastore/statement/#{product}/#{statement}"] +
+        expected_operation_metrics(operation, product)
+    end
+
+    def expected_operation_metrics(operation, product = "ActiveRecord")
+      ["Datastore/operation/#{product}/#{operation}",
+        "Datastore/#{product}/allOther",
+        "Datastore/#{product}/all",
+        "Datastore/allOther",
+        "Datastore/all"]
+    end
+  end
+end