mmtrix_rpm 1.0.0.1

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

@@ -0,0 +1,257 @@
+# 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::MiddlewareProxyTest < Minitest::Test
+
+  def setup
+    Mmtrix::Agent.drop_buffered_data
+  end
+
+  def test_generator_creates_wrapped_instances
+    middleware_class = Class.new
+
+    generator = Mmtrix::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+    wrapped_instance  = generator.new
+
+    assert_kind_of(Mmtrix::Agent::Instrumentation::MiddlewareProxy, wrapped_instance)
+    assert_kind_of(middleware_class, wrapped_instance.target)
+  end
+
+  def test_generator_passes_through_initialize_args
+    middleware_class = Class.new do
+      attr_reader :initialize_args
+
+      def initialize(*args)
+        @initialize_args = args
+      end
+    end
+
+    generator = Mmtrix::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+    wrapped_instance = generator.new('abc', 123)
+
+    assert_equal(['abc', 123], wrapped_instance.target.initialize_args)
+  end
+
+  def test_generator_passes_through_block_to_initialize
+    middleware_class = Class.new do
+      attr_reader :initialize_args
+
+      def initialize(*args, &blk)
+        @initialize_args = args
+        blk.call
+      end
+    end
+
+    generator = Mmtrix::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+
+    block_called = false
+    wrapped_instance = generator.new('abc', 123) do
+      block_called = true
+    end
+
+    assert block_called
+    assert_equal(['abc', 123], wrapped_instance.target.initialize_args)
+  end
+
+  def test_anonymous_class_naming
+    middleware_class = Class.new
+    wrapped_instance = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(middleware_class.new)
+
+    name = wrapped_instance.transaction_options[:transaction_name]
+    assert_equal("Middleware/Rack/AnonymousClass/call", name)
+  end
+
+  class BaseForAnonymous
+  end
+
+  def test_anonymous_derived_class_naming
+    middleware_class = Class.new(BaseForAnonymous)
+    wrapped_instance = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(middleware_class.new)
+
+    name = wrapped_instance.transaction_options[:transaction_name]
+    assert_equal("Middleware/Rack/#{BaseForAnonymous.name}/call", name)
+  end
+
+  def test_does_not_wrap_sinatra_apps
+    sinatra_dummy_module = Module.new
+    sinatra_dummy_class  = Class.new(Object)
+    app_class            = Class.new(sinatra_dummy_class)
+
+    with_constant_defined(:'::Sinatra', sinatra_dummy_module) do
+      with_constant_defined(:'::Sinatra::Base', sinatra_dummy_class) do
+        app = app_class.new
+
+        wrapped = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+
+        assert_same(app, wrapped)
+      end
+    end
+  end
+
+  def test_does_not_wrap_instrumented_middlewares
+    app_class = Class.new do
+      def _nr_has_middleware_tracing
+        true
+      end
+    end
+
+    app = app_class.new
+
+    wrapped = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+
+    assert_same(app, wrapped)
+  end
+
+  def test_should_wrap_non_instrumented_middlewares
+    app_class = Class.new do
+      def call(env)
+        :yay
+      end
+    end
+
+    app = app_class.new
+
+    wrapped = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+
+    assert_kind_of(Mmtrix::Agent::Instrumentation::MiddlewareProxy, wrapped)
+  end
+
+  def test_call_should_proxy_to_target_when_in_transaction
+    call_was_called = false
+    call_received   = nil
+
+    app = lambda do |env|
+      call_was_called = true
+      call_received   = env
+      :super_duper
+    end
+
+    wrapped = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+    env = {}
+
+    ret = nil
+    in_transaction do
+      ret = wrapped.call(env)
+    end
+
+    assert(call_was_called)
+    assert_equal(:super_duper, ret)
+    assert_same(env, call_received)
+  end
+
+  def test_call_should_proxy_to_target_when_not_in_transaction
+    call_was_called = false
+    call_received   = nil
+
+    app = lambda do |env|
+      call_was_called = true
+      call_received   = env
+      :super_duper
+    end
+
+    wrapped = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+    env = {}
+    ret = wrapped.call(env)
+
+    assert(call_was_called)
+    assert_equal(:super_duper, ret)
+    assert_same(env, call_received)
+  end
+
+  def test_should_start_transaction_if_none_is_running
+    app = lambda do |env|
+      :super_duper
+    end
+
+    wrapped = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app)
+
+    wrapped.call({})
+
+    assert_metrics_recorded("HttpDispatcher")
+  end
+
+  def test_should_respect_force_transaction_flag
+    app = lambda do |env|
+      :super_duper
+    end
+
+    wrapped = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+
+    in_transaction('Controller/foo', :category => :controller) do
+      wrapped.call({})
+    end
+
+    assert_metrics_recorded('Controller/Rack/Proc/call')
+  end
+
+  def test_should_get_the_right_name_when_target_is_a_class
+    target_class = Class.new do
+      def self.name
+        "GreatClass"
+      end
+
+      def self.call(env)
+        :super_duper
+      end
+    end
+
+    wrapped = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(target_class, true)
+
+    wrapped.call({})
+
+    assert_metrics_recorded('Controller/Rack/GreatClass/call')
+  end
+
+  def test_should_emit_events_once
+    app = Proc.new { |env| [200, {}, ["nothing"]]}
+    middleware = Proc.new { |env| app.call(env) }
+    wrapped_app = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+    wrapped_middleware = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(middleware, true)
+
+    before_call_count = 0
+    after_call_count = 0
+
+    Mmtrix::Agent.instance.events.subscribe(:before_call) { before_call_count += 1 }
+    Mmtrix::Agent.instance.events.subscribe(:after_call) { after_call_count += 1 }
+
+    result = wrapped_middleware.call({})
+    assert_equal 1, before_call_count
+    assert_equal 1, after_call_count
+  end
+
+  def test_before_call_should_receive_rack_env_hash
+    app = Proc.new { |env| [200, {}, ["nothing"]]}
+    wrapped_app = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+
+    original_env = {}
+    env_from_before_call = nil
+
+    Mmtrix::Agent.instance.events.subscribe(:before_call) { |env| env_from_before_call = env }
+
+    wrapped_app.call(original_env)
+    assert_same original_env, env_from_before_call
+  end
+
+  def test_before_call_should_receive_rack_env_hash
+    app = Proc.new { |env| [200, {}, ["nothing"]] }
+    wrapped_app = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+
+    original_env = {}
+    env_from_after_call = nil
+    result_from_after_call = nil
+
+    Mmtrix::Agent.instance.events.subscribe(:after_call) do |env, result|
+      env_from_after_call = env
+      result_from_after_call = result
+    end
+
+    result = wrapped_app.call(original_env)
+
+    assert_same original_env, env_from_after_call
+    assert_same result, result_from_after_call
+  end
+end
+

data/test/mmtrix/agent/instrumentation/middleware_tracing_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/instrumentation/middleware_tracing'
+
+class Mmtrix::Agent::Instrumentation::MiddlewareTracingTest < Minitest::Test
+  class UserError < StandardError
+  end
+
+  class HostClass
+    include Mmtrix::Agent::Instrumentation::MiddlewareTracing
+
+    attr_reader :category
+
+    def initialize(&blk)
+      @action = blk
+    end
+
+    def target
+      self
+    end
+
+    def transaction_options
+      {}
+    end
+
+    def traced_call(env)
+      @action.call
+    end
+  end
+
+  def test_dont_block_errors_during_malfunctioning_transaction
+    Mmtrix::Agent::Transaction.stubs(:start).returns(nil)
+
+    middleware = HostClass.new { raise UserError }
+    assert_raises(UserError) do
+      middleware.call({})
+    end
+  end
+
+  def test_dont_raise_when_transaction_start_fails
+    Mmtrix::Agent::Transaction.stubs(:start).returns(nil)
+
+    middleware = HostClass.new { [200, {}, ['hi!']] }
+    middleware.call({})
+  end
+end

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

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# 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 'net/http'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'mmtrix/agent/cross_app_tracing'
+
+class Mmtrix::Agent::Instrumentation::NetInstrumentationTest < Minitest::Test
+  def setup
+    Mmtrix::Agent.manual_start(
+      :"cross_application_tracer.enabled" => false,
+      :"transaction_tracer.enabled"       => true,
+      :cross_process_id                   => '269975#22824',
+      :encoding_key                       => 'gringletoes'
+    )
+
+    @socket = fixture_tcp_socket( @response )
+
+    Mmtrix::Agent.instance.stats_engine.clear_stats
+  end
+
+  def test_scope_stack_integrity_maintained_on_request_failure
+    @socket.stubs(:write).raises('fake network error')
+    with_config(:"cross_application_tracer.enabled" => true) do
+      state    = Mmtrix::Agent::TransactionState.tl_get
+      stack    = state.traced_method_stack
+      expected = stack.push_frame(state, 'dummy')
+      Net::HTTP.get(URI.parse('http://www.google.com/index.html')) rescue nil
+      stack.pop_frame(state, expected, 42, Time.now.to_f)
+    end
+  end
+
+end

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

@@ -0,0 +1,103 @@
+# 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::QueueTimeTest < Minitest::Test
+  include Mmtrix::Agent::Instrumentation
+
+  def setup
+    freeze_time
+  end
+
+  def teardown
+    Mmtrix::Agent.drop_buffered_data
+  end
+
+  def test_parse_frontend_timestamp_given_queue_start_header
+    header = { 'HTTP_X_QUEUE_START' => format_header_time(Time.now - 60) }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
+  end
+
+  def test_parse_frontend_timestamp_given_request_start_header
+    header = { 'HTTP_X_REQUEST_START' => format_header_time(Time.now - 60) }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
+  end
+
+  def test_parse_frontend_timestamp_given_middleware_start_header
+    header = { 'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 60) }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
+  end
+
+  def test_parse_frontend_timestamp_from_earliest_header
+    headers = { 'HTTP_X_REQUEST_START'    => format_header_time(Time.now - 63),
+                'HTTP_X_QUEUE_START'      => format_header_time(Time.now - 62),
+                'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 61)}
+
+    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.001)
+  end
+
+  def test_parse_frontend_timestamp_from_earliest_header_out_of_order
+    headers = { 'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 63),
+                'HTTP_X_REQUEST_START'    => format_header_time(Time.now - 62),
+                'HTTP_X_QUEUE_START'      => format_header_time(Time.now - 61) }
+
+    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.001)
+  end
+
+  def test_parse_frontend_timestamp_from_header_in_seconds
+    header = { 'HTTP_X_QUEUE_START' => "t=#{Time.now.to_f - 60}" }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
+  end
+
+  def test_parse_frontend_timestamp_from_header_in_milliseconds
+    header = { 'HTTP_X_QUEUE_START' => "t=#{(Time.now.to_f - 60) * 1_000}" }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
+  end
+
+  def test_parse_frontend_timestamp_from_header_with_multiple_servers
+    now = Time.now.to_f
+    header = { 'HTTP_X_QUEUE_START' => "servera t=#{now - 60}, serverb t=#{now - 30}" }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
+  end
+
+  def test_parse_frontend_timestamp_from_header_missing_t_equals
+    header = { 'HTTP_X_REQUEST_START' => (Time.now.to_f - 60).to_s }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.001)
+  end
+
+  def test_parse_frontend_timestamp_from_header_negative
+    now = Time.now
+    the_future = Time.at(now.to_f + 60)
+    header = { 'HTTP_X_REQUEST_START' => the_future.to_f.to_s }
+    assert_in_delta(now, QueueTime.parse_frontend_timestamp(header, now), 0.001)
+  end
+
+  def test_parsing_malformed_header
+    header = { 'HTTP_X_REQUEST_START' => 'gobledy gook' }
+
+    assert_nil QueueTime.parse_frontend_timestamp(header)
+  end
+
+  def test_parse_timestamp_can_identify_unit
+    now = Time.now.to_f
+    assert_in_delta(now, QueueTime.parse_timestamp(now.to_f.to_s).to_f, 0.001)
+    assert_in_delta(now, QueueTime.parse_timestamp((now.to_f * 1_000).to_s).to_f, 0.001)
+    assert_in_delta(now, QueueTime.parse_timestamp((now.to_f * 1_000_000).to_s).to_f, 0.001)
+  end
+
+  def format_header_time(time=Time.now)
+    "t=#{(time.to_f * 1_000_000).to_i}"
+  end
+
+  def seconds_ago(seconds)
+    Time.at(Time.now.to_f - seconds)
+  end
+
+  def assert_metric_value_in_delta(expected, metric_name, delta)
+    stats_engine = Mmtrix::Agent.instance.stats_engine
+    stats_engine.clear_stats
+    yield
+    assert_in_delta(expected, stats_engine.get_stats(metric_name).total_call_time, delta)
+  end
+end

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

@@ -0,0 +1,47 @@
+# 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/rack'
+
+class MinimalRackApp
+  def initialize(return_value)
+    @return_value = return_value
+  end
+
+  def call(env)
+    @return_value
+  end
+
+  include Mmtrix::Agent::Instrumentation::Rack
+end
+
+class Mmtrix::Agent::Instrumentation::RackTest < Minitest::Test
+  def test_basic_rack_app
+    # should return what we send in, even when instrumented
+    x = MinimalRackApp.new([200, {}, ["whee"]])
+    assert_equal [200, {}, ["whee"]], x.call({})
+    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
+  end
+
+  def test_basic_rack_app_404
+    x = MinimalRackApp.new([404, {}, ["whee"]])
+    assert_equal [404, {}, ["whee"]], x.call({})
+    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
+  end
+
+  def test_basic_rack_app_ignores_404
+    Mmtrix::Agent::Transaction.expects(:abort_transaction!)
+    x = MinimalRackApp.new([404, {}, ["whee"]])
+    assert_equal [404, {}, ["whee"]], x.call({})
+    assert_metrics_recorded(['Controller/Middleware/Rack/MinimalRackApp'])
+  end
+
+  def test_does_not_double_instrument_middlewares
+    x = MinimalRackApp.new([200, {}, ["whee"]])
+    wrapped_x = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(x)
+
+    assert_same(x, wrapped_x)
+  end
+end

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

@@ -0,0 +1,36 @@
+# 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/sequel_helper'
+
+module Mmtrix
+  module Agent
+    class SequelHelperTest < Minitest::Test
+      def test_product_name_from_adapter
+        expected_default = "Sequel"
+        default = Hash.new(expected_default)
+
+        adapter_to_name = {
+          :ibmdb => "IBMDB2",
+          :firebird => "Firebird",
+          :informix => "Informix",
+          :jdbc => "JDBC",
+          :mysql => "MySQL",
+          :mysql2 => "MySQL",
+          :oracle => "Oracle",
+          :postgres => "Postgres",
+          :sqlite => "SQLite"
+        }
+
+        default.merge(adapter_to_name).each do |adapter, name|
+          assert_equal name, Mmtrix::Agent::Instrumentation::SequelHelper.product_name_from_adapter(adapter)
+        end
+
+        default_result = Mmtrix::Agent::Instrumentation::SequelHelper.product_name_from_adapter("YouDontKnowThisAdapter")
+        assert_equal expected_default, default_result
+      end
+    end
+  end
+end

data/test/mmtrix/agent/instrumentation/sinatra/transaction_namer_test.rb

@@ -0,0 +1,55 @@
+# 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/sinatra/transaction_namer'
+
+module Mmtrix
+  module Agent
+    module Instrumentation
+      module Sinatra
+
+        class TransactionNamerTest < Minitest::Test
+
+          def test_transaction_name_for_route
+            env = { "mmtrix.last_route" => /^\/the_route$/}
+            request = stub(:request_method => "GET")
+            result = TransactionNamer.transaction_name_for_route(env, request)
+            assert_equal "GET the_route", result
+          end
+
+          def test_transaction_name_for_route_padrino
+            env = {}
+            route = stub(:original_path => "/path/:id")
+            request = stub(:route_obj => route, :request_method => "GET")
+            result = TransactionNamer.transaction_name_for_route(env, request)
+
+            assert_equal "GET path/:id", result
+          end
+
+          def test_transaction_name_for_route_without_routes
+            assert_nil TransactionNamer.transaction_name_for_route({}, nil)
+          end
+
+          def test_basic_sinatra_naming
+            assert_transaction_name "(unknown)", "(unknown)"
+
+            # Sinatra < 1.4 style regexes
+            assert_transaction_name "will_boom", "^/will_boom$"
+            assert_transaction_name "hello/([^/?#]+)", "^/hello/([^/?#]+)$"
+
+            # Sinatra 1.4 style regexs
+            assert_transaction_name "will_boom", "\A/will_boom\z"
+            assert_transaction_name "hello/([^/?#]+)", "\A/hello/([^/?#]+)\z"
+          end
+
+          def assert_transaction_name(expected, original)
+            assert_equal expected, TransactionNamer.transaction_name(original, nil)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# 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/sinatra'
+
+class Mmtrix::Agent::Instrumentation::SinatraTest < Minitest::Test
+
+  # This fake app is not an actual Sinatra app to avoid having our unit tests
+  # take a dependency directly on it. If you need actual Sinatra classes, go
+  # write the test in the multiver suite.
+  class SinatraTestApp
+    include Mmtrix::Agent::Instrumentation::Sinatra
+
+    attr_accessor :env, :request
+
+    def initialize
+      @env = {}
+    end
+  end
+
+  def setup
+    @app = SinatraTestApp.new
+  end
+
+  def test_mmtrix_request_headers
+    expected_headers = {:fake => :header}
+    @app.request = mock('request', :env => expected_headers)
+
+    state = Mmtrix::Agent::TransactionState.tl_get
+
+    assert_equal(@app.mmtrix_request_headers(state), expected_headers)
+  end
+
+  def test_process_route_with_bad_arguments
+    @app.stubs(:env).raises("Boo")
+    @app.expects(:process_route_without_mmtrix).once
+    @app.process_route_with_mmtrix
+  end
+
+  def test_route_eval_with_bad_params
+    @app.stubs(:env).raises("Boo")
+    @app.expects(:route_eval_without_mmtrix).once
+    @app.route_eval_with_mmtrix
+  end
+
+  def test_route_eval_without_last_route_doesnt_set_transaction_name
+    @app.stubs(:env).returns({})
+    @app.expects(:route_eval_without_mmtrix).once
+    Mmtrix::Agent.expects(:set_transaction_name).never
+    @app.route_eval_with_mmtrix
+  end
+
+  def test_injects_middleware
+    SinatraTestApp.stubs(:middleware).returns([])
+
+    SinatraTestApp.expects(:build_without_mmtrix).once
+    SinatraTestApp.expects(:use).at_least(2)
+
+    SinatraTestApp.build_with_mmtrix(@app)
+  end
+
+  def test_doesnt_inject_already_existing_middleware
+    default_middlewares = SinatraTestApp.mmtrix_middlewares
+    # mock up the return value of Sinatra's #middleware method, which returns an
+    # Array of Arrays.
+    middleware_info = default_middlewares.map { |m| [m] }
+    SinatraTestApp.stubs(:middleware).returns(middleware_info)
+
+    SinatraTestApp.expects(:build_without_mmtrix).once
+    SinatraTestApp.expects(:use).never
+
+    SinatraTestApp.build_with_mmtrix(@app)
+  end
+
+  def assert_transaction_name(expected, original)
+    assert_equal expected, Mmtrix::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name(original, nil)
+  end
+end