mmtrix_rpm 1.0.0.1

data/test/performance/suites/marshalling.rb

@@ -0,0 +1,156 @@
+# 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.join(File.dirname(__FILE__), '..', '..', 'agent_helper')
+
+class Marshalling < Performance::TestCase
+  def setup
+    @payload = build_analytics_events_payload
+    @tt_payload = build_transaction_trace_payload
+  end
+
+  def test_basic_marshalling_json
+    with_config(:normalize_json_string_encodings => true) do
+      marshaller = Mmtrix::Agent::MmtrixService::JsonMarshaller.new
+      measure do
+        marshaller.dump(@payload)
+        marshaller.dump(@tt_payload)
+      end
+    end
+  end
+
+  def test_json_marshalling_binary_strings
+    with_config(:normalize_json_string_encodings => true) do
+      marshaller = Mmtrix::Agent::MmtrixService::JsonMarshaller.new
+      convert_strings_to_binary(@payload)
+      convert_strings_to_binary(@tt_payload)
+      measure do
+        marshaller.dump(@payload)
+        marshaller.dump(@tt_payload)
+      end
+    end
+  end
+
+  def test_json_marshalling_utf16_strings
+    with_config(:normalize_json_string_encodings => true) do
+      marshaller = Mmtrix::Agent::MmtrixService::JsonMarshaller.new
+      convert_strings_to_utf16(@payload)
+      convert_strings_to_utf16(@tt_payload)
+      measure do
+        marshaller.dump(@payload)
+        marshaller.dump(@tt_payload)
+      end
+    end
+  end
+
+  def test_json_marshalling_latin1_strings
+    with_config(:normalize_json_string_encodings => true) do
+      marshaller = Mmtrix::Agent::MmtrixService::JsonMarshaller.new
+      convert_strings_to_latin1(@payload)
+      convert_strings_to_latin1(@tt_payload)
+      measure do
+        marshaller.dump(@payload)
+        marshaller.dump(@tt_payload)
+      end
+    end
+  end
+
+  def test_basic_marshalling_pruby
+    marshaller = Mmtrix::Agent::MmtrixService::PrubyMarshaller.new
+    measure do
+      marshaller.dump(@payload)
+      marshaller.dump(@tt_payload)
+    end
+  end
+
+  # Skips Strings used as Hash keys, since they are frozen
+  def each_string(object, &blk)
+    case object
+    when String
+      blk.call(object)
+    when Array
+      object.map! { |x| each_string(x, &blk) }
+    when Hash
+      object.values.each do |v|
+        each_string(v, &blk)
+      end
+    end
+  end
+
+  BYTE_ALPHABET = (0..255).to_a.freeze
+
+  def generate_random_string(length)
+    bytes = []
+    meth = BYTE_ALPHABET.respond_to?(:sample) ? :sample : :choice
+    length.times { bytes << BYTE_ALPHABET.send(meth) }
+    bytes.pack("C*")
+  end
+
+  def convert_strings_to_binary(object)
+    each_string(object) do |s|
+      s.replace(generate_random_string(s.bytesize))
+    end
+  end
+
+  def convert_strings_to_utf16(object)
+    each_string(object) do |s|
+      if s.respond_to?(:encode!)
+        s.encode!('UTF-16')
+      else
+        require 'iconv'
+        s.replace(Iconv.conv('UTF-16', 'UTF-8', s))
+      end
+    end
+  end
+
+  def convert_strings_to_latin1(object)
+    return object unless "".respond_to?(:force_encoding)
+
+    each_string(object) do |s|
+      s.replace(generate_random_string(s.bytesize)).force_encoding('ISO-8859-1')
+    end
+  end
+
+  # Build an object graph that approximates a transaction trace in structure
+  def build_transaction_trace_payload(depth=6)
+    root = []
+    fanout = depth
+    fanout.times do |i|
+      node = [
+        i * rand(10),
+        i * rand(10),
+        "This/Is/The/Name/Of/A/Transaction/Trace/Node/Depth/#{depth}/#{i}",
+        {
+          "sql" => "SELECT #{(0..100).to_a.join(",")}"
+        },
+        []
+      ]
+      node[-1] = build_transaction_trace_payload(depth-1) if depth > 0
+      root << node
+    end
+    root
+  end
+
+  # Build an object graph that approximates a large analytics_event_data payload
+  def build_analytics_events_payload
+    events = []
+    1000.times do
+      event = {
+        'timestamp'        => Time.now.to_f,
+        'name'             => "Controller/foo/bar",
+        'type'             => "Transaction",
+        'duration'         => rand,
+        'databaseDuration' => rand,
+        'databaseCallCount'=> rand,
+        'gcCumulative'     => rand,
+        'host'             => 'lo-calhost',
+        'color'            => 'blue-green',
+        'shape'            => 'squarish',
+        'texture'          => 'sort of lumpy like a bag of frozen peas'
+      }
+      events << [event, {}]
+    end
+    [rand(1000000), events]
+  end
+end

data/test/performance/suites/queue_time.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+class QueueTimePerfTests < Performance::TestCase
+  def setup
+    @headers = [
+      { 'HTTP_X_REQUEST_START' => "t=1409849996.2152882" },
+      { 'HTTP_X_REQUEST_START' => "t=1409850011020.236"  },
+      { 'HTTP_X_REQUEST_START' => "t=1409850011020236.0" },
+    ]
+  end
+
+  def test_queue_time_parsing
+    measure do
+      @headers.each do |h|
+        Mmtrix::Agent::Instrumentation::QueueTime.parse_frontend_timestamp(h)
+      end
+    end
+  end
+end

data/test/performance/suites/rack_middleware.rb

@@ -0,0 +1,136 @@
+# 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 'rack'
+
+class RackMiddleware < Performance::TestCase
+  class TestMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    end
+  end
+
+  # We want 10 middlewares each with different names so that we end up with
+  # different metric names for each one. This is more realistic than using the
+  # same name 10 times.
+  class TestMiddlewareA < TestMiddleware; def call(e); @app.call(e); end; end
+  class TestMiddlewareB < TestMiddleware; def call(e); @app.call(e); end; end
+  class TestMiddlewareC < TestMiddleware; def call(e); @app.call(e); end; end
+  class TestMiddlewareD < TestMiddleware; def call(e); @app.call(e); end; end
+  class TestMiddlewareE < TestMiddleware; def call(e); @app.call(e); end; end
+  class TestMiddlewareF < TestMiddleware; def call(e); @app.call(e); end; end
+  class TestMiddlewareG < TestMiddleware; def call(e); @app.call(e); end; end
+  class TestMiddlewareH < TestMiddleware; def call(e); @app.call(e); end; end
+  class TestMiddlewareI < TestMiddleware; def call(e); @app.call(e); end; end
+  class TestMiddlewareJ < TestMiddleware; def call(e); @app.call(e); end; end
+
+  class TestAppWithParams
+    def call(env)
+      params = {
+        'user' => {
+          'shipping_address' => {
+            'street' => '1234 Nowhere Road',
+            'city'   => 'Nowhere',
+            'state'  => 'TX'
+          },
+          'billing_address' => {
+            'street' => '4321 Nowhere Lane',
+            'city'   => 'Nowhere',
+            'state'  => 'TX'
+          }
+        }
+      }
+      perform_action_with_mmtrix_trace(:name => 'dorkbot', :params => params) do
+        [200, { 'Content-Type' => 'text/html' }, ['<body>hi</body>']]
+      end
+    end
+  end
+
+  class TestApp
+    def call(env)
+      [200, { 'Content-Type' => 'text/html' }, ['<body>hi</body>']]
+    end
+  end
+
+  def setup
+    require 'mmtrix/rack/browser_monitoring'
+
+    @config = {
+      :beacon          => 'beacon',
+      :browser_key     => 'browserKey',
+      :js_agent_loader => 'loader',
+      :encoding_key    => 'lolz',
+      :application_id  => '5, 6', # collector can return app multiple ids
+      :'rum.enabled'   => true,
+      :license_key     => 'a' * 40,
+      :developer_mode  => false
+    }
+    Mmtrix::Agent.config.add_config_for_testing(@config)
+
+    Mmtrix::Agent.manual_start(
+      :developer_mode => false,
+      :monitor_mode   => false
+    )
+
+    Mmtrix::Agent.agent.events.notify(:finished_configuring)
+
+    middlewares = [
+      TestMiddlewareA,
+      TestMiddlewareB,
+      TestMiddlewareC,
+      TestMiddlewareD,
+      TestMiddlewareE,
+      TestMiddlewareF,
+      TestMiddlewareG,
+      TestMiddlewareH,
+      TestMiddlewareI,
+      TestMiddlewareJ,
+      Mmtrix::Rack::BrowserMonitoring
+    ]
+
+    TestAppWithParams.class_eval do
+      include Mmtrix::Agent::Instrumentation::ControllerInstrumentation
+    end
+
+    @stack = Rack::Builder.new do
+      middlewares.each { |m| use m }
+      run TestApp.new
+    end.to_app
+
+    @stack_with_params = Rack::Builder.new do
+      middlewares.each { |m| use m }
+      run TestAppWithParams.new
+    end.to_app
+
+    @env = {
+      'SCRIPT_NAME'  => '',
+      'PATH_INFO'    => '/users/12/blogs',
+      'QUERY_STRING' => 'q=foobar'
+    }
+  end
+
+  def test_basic_middleware_stack()
+    measure do
+      @stack.call(@env.dup)
+    end
+  end
+
+  def test_request_with_params_capture_params_off
+    measure do
+      @stack_with_params.call(@env.dup)
+    end
+  end
+
+  def test_request_with_params_capture_params_on
+    Mmtrix::Agent.config.add_config_for_testing(:capture_params => true)
+    Mmtrix::Agent.agent.events.notify(:finished_configuring)
+    measure do
+      @stack_with_params.call(@env.dup)
+    end
+  end
+end

data/test/performance/suites/rum_autoinsertion.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+class RumAutoInsertion < Performance::TestCase
+  attr_reader :browser_monitor, :html, :html_with_meta, :html_with_meta_after
+
+  def setup
+    # Don't require until we're actually running tests to avoid weirdness in
+    # the parent runner process...
+    require 'mmtrix/agent'
+    require 'mmtrix/rack/browser_monitoring'
+
+    Mmtrix::Agent.manual_start
+    @config = {
+      :beacon                 => 'beacon',
+      :browser_key            => 'browserKey',
+      :application_id         => '5, 6', # collector can return app multiple ids
+      :'rum.enabled'          => true,
+      :license_key            => 'a' * 40,
+      :js_agent_loader        => 'loader'
+    }
+    Mmtrix::Agent.config.add_config_for_testing(@config)
+
+    @app = Class.new do
+      attr_accessor :text
+
+      def call(*_)
+        [200, { "Content-Type" => "text/html" }, [text]]
+      end
+    end.new
+
+    @browser_monitor = Mmtrix::Rack::BrowserMonitoring.new(@app)
+
+    @html = "<html><head>#{'<script>alert("boo");</script>' * 1_000}</head><body></body></html>"
+    @html_with_meta = "<html><head><meta http-equiv='X-UA-Compatible' content='IE=7'/>#{'<script>alert("boo");</script>' * 1_000}</head><body></body></html>"
+    @html_with_meta_after = "<html><head>#{'<script>alert("boo");</script>' * 1_000}<meta http-equiv='X-UA-Compatible' content='IE=7'/></head><body></body></html>"
+
+    host_class = Class.new do
+      include ::Mmtrix::Agent::Instrumentation::ControllerInstrumentation
+
+      def run
+        yield
+      end
+      add_transaction_tracer :run
+    end
+
+    @host = host_class.new
+  end
+
+  def teardown
+    Mmtrix::Agent.shutdown
+  end
+
+  def test_rum_autoinsertion
+    run_autoinstrument_source(html)
+  end
+
+  def test_rum_autoinsertion_with_x_ua_compatible
+    run_autoinstrument_source(html_with_meta)
+  end
+
+  def test_rum_autoinsertion_with_x_ua_compatible_after
+    run_autoinstrument_source(html_with_meta_after)
+  end
+
+  def run_autoinstrument_source(text)
+    @app.text = text
+    @host.run do
+      measure do
+        browser_monitor.call({})
+      end
+    end
+  end
+end

data/test/performance/suites/sql_obfuscation.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+class SqlObfuscationTests < Performance::TestCase
+  def setup
+    require 'mmtrix/agent/database'
+    @long_query  = Mmtrix::Agent::Database::Statement.new("SELECT DISTINCT table0.* FROM `table0` INNER JOIN `table1` ON `table1`.`metric_id` = `table0`.`id` LEFT JOIN `table3` ON table3.id_column = table0.id_column AND table3.metric_id = table0.id WHERE `table1`.`other_id` IN (92776, 49992, 61710, 84911, 90744, 40647) AND `table0`.`id_column` = 81067 AND `table0`.`col12` = '' AND ((table0.id_column=81067 )) AND ((table3.timestamp IS NULL OR table3.timestamp > 1406810459)) AND (((table0.name LIKE 'WebTransaction/%') OR ((table0.name LIKE 'OtherTransaction/%/%') AND (table0.name NOT LIKE '%/all')))) LIMIT 2250")
+    @short_query = Mmtrix::Agent::Database::Statement.new("SELECT * FROM `table` WHERE id=2540250 AND name LIKE 'OtherTransaction/%/%'")
+
+    @long_query_pg = @long_query.dup
+    @long_query_pg.adapter = 'postgresql'
+    @short_query_pg = @short_query.dup
+    @short_query_pg.adapter = 'postgresql'
+  end
+
+  def test_obfuscate_sql
+    measure do
+      Mmtrix::Agent::Database.obfuscate_sql(@long_query)
+      Mmtrix::Agent::Database.obfuscate_sql(@short_query)
+    end
+  end
+
+  def test_obfuscate_sql_postgres
+    measure do
+      Mmtrix::Agent::Database.obfuscate_sql(@long_query_pg)
+      Mmtrix::Agent::Database.obfuscate_sql(@short_query_pg)
+    end    
+  end
+end

data/test/performance/suites/startup.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+class StartupShutdown < Performance::TestCase
+  def test_startup_shutdown
+    measure do
+      Mmtrix::Agent.manual_start
+      Mmtrix::Agent.shutdown
+    end
+  end
+end

data/test/performance/suites/stats_hash.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+class StatsHashPerfTest < Performance::TestCase
+  def setup
+    @hash = Mmtrix::Agent::StatsHash.new
+    @specs = (1..100).map { |i| Mmtrix::MetricSpec.new("foo#{i}") }
+  end
+
+  def test_record
+    measure do
+      hash = Mmtrix::Agent::StatsHash.new
+      @specs.each do |spec|
+        hash.record(spec, 1)
+      end
+    end
+  end
+
+  def test_merge
+    measure do
+      incoming = Mmtrix::Agent::StatsHash.new
+      @specs.each do |i|
+        incoming.record(Mmtrix::MetricSpec.new("foo#{i}"), 1)
+      end
+
+      hash = Mmtrix::Agent::StatsHash.new
+      hash.merge!(incoming)
+    end
+  end
+end

data/test/performance/suites/thread_profiling.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+class ThreadProfiling < Performance::TestCase
+  def recurse(n, final)
+    if n == 0
+      final.call
+    else
+      recurse(n-1, final)
+    end
+  end
+
+  def block
+    @mutex.synchronize do
+      @cvar.wait(@mutex)
+    end
+  end
+
+  def setup
+    require 'mmtrix/agent/threading/backtrace_service'
+
+    @nthreads = 16
+
+    @mutex = Mutex.new
+    @cvar = ConditionVariable.new
+    @threadq = Queue.new
+    @threads = []
+
+    @nthreads.times do
+      @threads << Thread.new do
+        @threadq << self
+        transaction_state = Mmtrix::Agent::TransactionState.tl_get
+        def transaction_state.in_web_transaction?; true; end
+        recurse(50, method(:block))
+      end
+    end
+
+    # Ensure that all threads have had a chance to start up
+    started_count = 0
+    while started_count < @nthreads do
+      @threadq.pop
+      started_count += 1
+    end
+
+    @service = Mmtrix::Agent::Threading::BacktraceService.new
+    @worker_loop = @service.worker_loop
+    def @worker_loop.run; end # we want to drive it manually
+  end
+
+  def teardown
+    @cvar.broadcast
+    @threads.each(&:join)
+  rescue Exception => e
+    if e.message =~ /Deadlock/
+      Thread.list.select(&:alive?).each do |t|
+        STDERR.puts "*" * 80
+        STDERR.puts "Live thread: #{t.inspect}"
+        STDERR.puts "Backtrace:"
+        STDERR.puts (t.backtrace || []).join("\n")
+        STDERR.puts "*" * 80
+      end
+    end
+
+    raise e
+  end
+
+  def test_gather_backtraces
+    @service.subscribe(Mmtrix::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
+    measure do
+      @service.poll
+    end
+    @service.unsubscribe(Mmtrix::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
+  end
+
+  def test_gather_backtraces_subscribed
+    @service.subscribe('eagle')
+    measure do
+      t0 = Time.now.to_f
+      @service.poll
+      payload = {
+        :name => 'eagle',
+        :bucket => :request,
+        :start_timestamp => t0,
+        :duration => Time.now.to_f-t0,
+        :thread => @threads.sample
+      }
+      @service.on_transaction_finished(payload)
+    end
+    @service.unsubscribe('eagle')
+  end
+
+  def test_generating_traces
+    require 'mmtrix/agent/threading/thread_profile'
+
+    measure do
+      profile = ::Mmtrix::Agent::Threading::ThreadProfile.new({})
+
+      aggregate_lots_of_nodes(profile, 5, [])
+
+      profile.generate_traces
+    end
+  end
+
+  def aggregate_lots_of_nodes(profile, depth, trace)
+    if depth > 0
+      7.times do |i|
+        trace.push("path#{i}:#{i+50}:in `depth#{depth}'")
+        aggregate_lots_of_nodes(profile, depth-1, trace)
+        trace.pop
+      end
+    else
+      profile.aggregate(trace, :request, Thread.current)
+    end
+  end
+end

data/test/performance/suites/trace_execution_scoped.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+class TestClass
+  def method_1
+    trace_execution_scoped(['a', 'b']) do
+    end
+  end
+
+  def method_2
+    callback = Proc.new { ['c', 'd'] }
+    trace_execution_scoped(['a', 'b'], { :additional_metrics_callback => callback }) do
+    end
+  end
+end
+
+class TraceExecutionScopedTests < Performance::TestCase
+  def setup
+    @test_class = TestClass.new
+    TestClass.instance_eval('include Mmtrix::Agent::MethodTracer')
+    require 'mmtrix/agent/method_tracer'
+  end
+
+  def test_without_callback
+    measure { @test_class.method_1 }
+  end
+
+  def test_with_callback
+    measure { @test_class.method_2 }
+  end
+end