mmtrix_rpm 1.0.0.1

data/test/mmtrix/agent/threading/thread_profile_test.rb

@@ -0,0 +1,272 @@
+# 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/threading/backtrace_service'
+require 'mmtrix/agent/threading/thread_profile'
+require 'mmtrix/agent/threading/threaded_test_case'
+
+if Mmtrix::Agent::Threading::BacktraceService.is_supported?
+
+  module Mmtrix::Agent::Threading
+    class ThreadProfileTest < Minitest::Test
+      include ThreadedTestCase
+
+      def setup
+        setup_fake_threads
+
+        @single_trace = [
+          "irb.rb:69:in `catch'",
+          "irb.rb:69:in `start'",
+          "irb:12:in `<main>'"
+        ]
+
+        @profile = ThreadProfile.new
+
+        # Run the worker_loop for the thread profile based on two iterations
+        # This takes time fussiness out of the equation and keeps the tests stable
+        @profile.instance_variable_set(:@worker_loop, Mmtrix::Agent::WorkerLoop.new(:limit => 2))
+      end
+
+      def teardown
+        teardown_fake_threads
+      end
+
+      def target_for_shared_client_tests
+        @profile
+      end
+
+      def test_prune_tree
+        @profile.aggregate(@single_trace, :request, Thread.current)
+
+        @profile.convert_N_trace_nodes_to_arrays(1)
+
+        assert_equal 1, count_backtrace_nodes(@profile.traces[:request])
+      end
+
+      def test_prune_keeps_highest_counts
+        @profile.aggregate(@single_trace, :request, Thread.current)
+        @profile.aggregate(@single_trace, :other  , Thread.current)
+        @profile.aggregate(@single_trace, :other  , Thread.current)
+
+        @profile.convert_N_trace_nodes_to_arrays(1)
+
+        assert_equal 0, count_backtrace_nodes(@profile.traces[:request])
+        assert_equal 1, count_backtrace_nodes(@profile.traces[:other  ])
+      end
+
+      def test_prune_keeps_highest_count_then_depths
+        @profile.aggregate(@single_trace, :request, Thread.current)
+        @profile.aggregate(@single_trace, :other  , Thread.current)
+
+        @profile.convert_N_trace_nodes_to_arrays(2)
+
+        assert_equal 1, count_backtrace_nodes(@profile.traces[:request])
+        assert_equal 1, count_backtrace_nodes(@profile.traces[:other  ])
+      end
+
+      def build_well_known_trace(args={})
+        @profile = ThreadProfile.new(args)
+
+        thread = stub
+        trace = ["thread_profiler.py:1:in `<module>'"]
+        10.times { @profile.aggregate(trace, :other, thread) }
+
+        thread = stub
+        trace = [
+          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:489:in `__bootstrap'",
+          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:512:in `__bootstrap_inner'",
+          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:480:in `run'",
+          "thread_profiler.py:76:in `_profiler_loop'",
+          "thread_profiler.py:103:in `_run_profiler'",
+          "thread_profiler.py:165:in `collect_thread_stacks'"
+        ]
+        10.times { @profile.aggregate(trace, :agent, thread) }
+
+        @profile.increment_poll_count
+      end
+
+      WELL_KNOWN_TRACE_ENCODED = "eJy9klFPwjAUhf/LfW7WDQTUGBPUiYkGdAxelqXZRpGGrm1uS8xi/O924JQX\n9Un7dm77ndN7c19hlt7FCZxnWQZug7xYMYN6LSTHwDRA4KLWq53kl0CinEQh\nCUmW5zmBJH5axPPUk16MJ/E0/cGk0lLyyrGPS+uKamu943DQeX5HMtypz5In\nwv6vRCeZ1NoAGQ2PCDpvrOM1fRAlFtjQWyxq/qJxa+lj4zZaBeuuQpccrdDK\n0l4wolKU1OxftOoQLNTzIdL/EcjJafjnQYyVWjvrsDBMKNVOZBD1/jO27fPs\naBG+DoGr8fX9JJktpjftVry9A9unzGo=\n"
+
+      def test_to_collector_array
+        build_well_known_trace('profile_id' => 333)
+        @profile.stubs(:created_at).returns(1350403938892.524)
+        @profile.finished_at = 1350403939904.375
+
+        expected = [
+          333,
+          1350403938892.524,
+          1350403939904.375,
+          1,
+          WELL_KNOWN_TRACE_ENCODED,
+          2,
+          0
+        ]
+
+        assert_equal expected, @profile.to_collector_array(encoder)
+      end
+
+      def test_to_collector_array_with_identity_encoder
+        build_well_known_trace('profile_id' => 333)
+        @profile.stubs(:created_at).returns(12)
+        @profile.finished_at = 13
+
+        expected = [
+          333,
+          12,
+          13,
+          1,
+          @profile.generate_traces,
+          2,
+          0
+        ]
+
+        identity_encoder = Mmtrix::Agent::MmtrixService::PrubyMarshaller.new.default_encoder
+        assert_equal expected, @profile.to_collector_array(identity_encoder)
+      end
+
+      def test_to_collector_array_with_xray_session_id
+        build_well_known_trace('profile_id' => -1, 'x_ray_id' => 4242)
+        @profile.stubs(:created_at).returns(1350403938892.524)
+        @profile.finished_at = 1350403939904.375
+
+        expected = [
+          -1,
+          1350403938892.524,
+          1350403939904.375,
+          20,
+          WELL_KNOWN_TRACE_ENCODED,
+          2,
+          0,
+          4242
+        ]
+
+        assert_equal expected, @profile.to_collector_array(encoder)
+      end
+
+      def test_to_collector_array_with_bad_values
+        build_well_known_trace(:profile_id => -1)
+        @profile.stubs(:created_at).returns('')
+        @profile.finished_at = nil
+        @profile.instance_variable_set(:@poll_count, Rational(10, 1))
+        @profile.instance_variable_set(:@backtrace_count, nil)
+        @profile.instance_variable_set(:@unique_threads, nil)
+
+        expected = [
+          -1,
+          0.0,
+          0.0,
+          10,
+          WELL_KNOWN_TRACE_ENCODED,
+          0,
+          0
+        ]
+
+        assert_equal expected, @profile.to_collector_array(encoder)
+      end
+
+      def test_aggregate_should_increment_only_backtrace_count
+        backtrace_count = @profile.backtrace_count
+        failure_count = @profile.failure_count
+        @profile.aggregate(@single_trace, :request, Thread.current)
+
+        assert_equal backtrace_count + 1, @profile.backtrace_count
+        assert_equal failure_count, @profile.failure_count
+      end
+
+      def test_aggregate_increments_only_the_failure_count_with_nil_backtrace
+        backtrace_count = @profile.backtrace_count
+        failure_count = @profile.failure_count
+        @profile.aggregate(nil, :request, Thread.current)
+
+        assert_equal backtrace_count, @profile.backtrace_count
+        assert_equal failure_count + 1, @profile.failure_count
+      end
+
+      def test_aggregate_updates_created_at_timestamp
+        expected = freeze_time
+        @profile = ThreadProfile.new
+
+        @profile.aggregate(@single_trace, :request, Thread.current)
+        t0 = @profile.created_at
+
+        advance_time(5.0)
+        @profile.aggregate(@single_trace, :request, Thread.current)
+
+        assert_equal expected, t0
+        assert_equal expected, @profile.created_at
+      end
+
+      def test_aggregate_keeps_unique_thread_count
+        thread0 = stub
+        thread1 = stub
+
+        @profile.aggregate(@single_trace, :request, thread0)
+        @profile.aggregate(@single_trace, :request, thread0)
+        @profile.aggregate(@single_trace, :request, thread1)
+
+        assert_equal 2, @profile.unique_thread_count
+      end
+
+      SAMPLE_COUNT_POSITION = 3
+
+      def test_sample_count_for_thread_profiling
+        profile = ThreadProfile.new('x_ray_id' => nil)
+        profile.increment_poll_count
+
+        result = profile.to_collector_array(encoder)
+        assert_equal 1, result[SAMPLE_COUNT_POSITION]
+      end
+
+      def test_sample_count_for_xrays
+        profile = ThreadProfile.new('x_ray_id' => 123)
+        profile.aggregate(@single_trace, :request, Thread.current)
+
+        result = profile.to_collector_array(encoder)
+        assert_equal 1, result[SAMPLE_COUNT_POSITION]
+      end
+
+      def test_empty
+        profile = ThreadProfile.new
+        assert profile.empty?
+      end
+
+      def test_not_empty
+        profile = ThreadProfile.new
+        profile.aggregate([], :request, Thread.current)
+        assert_false profile.empty?
+      end
+
+      def encoder
+        Mmtrix::Agent::MmtrixService::JsonMarshaller.new.default_encoder
+      end
+
+      def count_backtrace_nodes(bt_node)
+        trees = bt_node.as_array
+
+        count = 0
+
+        trees.each do |tree|
+          count += rec_count_tree_nodes(tree)
+        end
+
+        count
+      end
+
+      def rec_count_tree_nodes(tree)
+        count = 1 # 1 for this node
+
+        children = tree[3]
+
+        children.each do |child|
+          count += rec_count_tree_nodes(child)
+        end
+
+        count
+      end
+    end
+
+  end
+end

data/test/mmtrix/agent/threading/threaded_test_case.rb

@@ -0,0 +1,18 @@
+# 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 'mmtrix/agent/threading/fake_thread'
+
+module ThreadedTestCase
+  def setup_fake_threads
+    @original_thread_class = Mmtrix::Agent::Threading::AgentThread.backing_thread_class
+    Mmtrix::Agent::Threading::AgentThread.backing_thread_class = FakeThread
+    FakeThread.list.clear
+  end
+
+  def teardown_fake_threads
+    Mmtrix::Agent::Threading::AgentThread.backing_thread_class = @original_thread_class
+    FakeThread.list.clear
+  end
+end

data/test/mmtrix/agent/traced_method_stack_test.rb

@@ -0,0 +1,187 @@
+# 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/traced_method_stack'
+
+class Mmtrix::Agent::TracedMethodStackTest < Minitest::Test
+  def setup
+    @frame_stack = Mmtrix::Agent::TracedMethodStack.new
+  end
+
+  def test_scope_overlap
+    freeze_time
+
+    in_transaction('orlando') do
+      self.class.trace_execution_scoped('disney') { advance_time(0.1) }
+    end
+
+    in_transaction('anaheim') do
+      self.class.trace_execution_scoped('disney') { advance_time(0.11) }
+    end
+
+    assert_metrics_recorded(
+      ['disney', 'orlando'] => {
+        :call_count      => 1,
+        :total_call_time => 0.1
+      },
+      ['disney', 'anaheim'] => {
+        :call_count      => 1,
+        :total_call_time => 0.11
+      },
+      'disney' => {
+        :call_count      => 2,
+        :total_call_time => 0.21
+      })
+  end
+
+  def test_children_time
+    state = Mmtrix::Agent::TransactionState.tl_get
+
+    freeze_time
+    expected1 = @frame_stack.push_frame(state, :a)
+    advance_time(0.001)
+    t2 = Time.now
+
+    expected2 = @frame_stack.push_frame(state, :b)
+    advance_time(0.002)
+    t3 = Time.now
+
+    expected = @frame_stack.push_frame(state, :c)
+    advance_time(0.003)
+    scope = @frame_stack.pop_frame(state, expected, "metric c", Time.now.to_f)
+
+    t4 = Time.now
+    assert_equal 0, scope.children_time
+
+    advance_time(0.001)
+    t5 = Time.now
+
+    expected = @frame_stack.push_frame(state, :d)
+    advance_time(0.002)
+    scope = @frame_stack.pop_frame(state, expected, "metric d", Time.now.to_f)
+
+    t6 = Time.now
+
+    assert_equal 0, scope.children_time
+
+    scope = @frame_stack.pop_frame(state, expected2, "metric b", Time.now.to_f)
+    assert_equal 'metric b', scope.name
+
+    assert_in_delta((t4 - t3) + (t6 - t5), scope.children_time, 0.0001)
+
+    scope = @frame_stack.pop_frame(state, expected1, "metric a", Time.now.to_f)
+    assert_equal scope.name, 'metric a'
+
+    assert_in_delta((t6 - t2), scope.children_time, 0.0001)
+  end
+
+
+  # test for when the scope stack contains an element only used for tts and not metrics
+  def test_simple_tt_only_scope
+    state = Mmtrix::Agent::TransactionState.tl_get
+
+    node1 = @frame_stack.push_frame(state, :a, 0)
+    node2 = @frame_stack.push_frame(state, :b, 10)
+    node3 = @frame_stack.push_frame(state, :c, 20)
+
+    @frame_stack.pop_frame(state, node3, "name a", 30)
+    @frame_stack.pop_frame(state, node2, "name b", 20)
+    @frame_stack.pop_frame(state, node1, "name c", 10)
+
+    assert_equal 0, node3.children_time
+    assert_equal 10, node2.children_time
+    assert_equal 10, node1.children_time
+
+    assert @frame_stack.empty?
+  end
+
+  def test_double_tt_only_scope
+    state = Mmtrix::Agent::TransactionState.tl_get
+
+    node1 = @frame_stack.push_frame(state, :a,  0)
+    node2 = @frame_stack.push_frame(state, :b, 10)
+    node3 = @frame_stack.push_frame(state, :c, 20)
+    node4 = @frame_stack.push_frame(state, :d, 30)
+
+    @frame_stack.pop_frame(state, node4, "name d", 40)
+    @frame_stack.pop_frame(state, node3, "name c", 30)
+    @frame_stack.pop_frame(state, node2, "name b", 20)
+    @frame_stack.pop_frame(state, node1, "name a", 10)
+
+    assert_equal  0, node4.children_time.round
+    assert_equal 10, node3.children_time.round
+    assert_equal 10, node2.children_time.round
+    assert_equal 10, node1.children_time.round
+
+    assert @frame_stack.empty?
+  end
+
+  def test_clear
+    state = Mmtrix::Agent::TransactionState.tl_get
+
+    @frame_stack.push_frame(state, :a)
+    @frame_stack.clear
+    assert_empty @frame_stack
+  end
+
+  def test_sampler_enabling
+    assert_sampler_enabled_with(true,  :'transaction_tracer.enabled' => true,  :developer_mode => false)
+    assert_sampler_enabled_with(true,  :'transaction_tracer.enabled' => false, :developer_mode => true)
+    assert_sampler_enabled_with(true,  :'transaction_tracer.enabled' => true,  :developer_mode => true)
+
+    assert_sampler_enabled_with(false, :'transaction_tracer.enabled' => false, :developer_mode => false)
+  end
+
+  def test_fetch_matching_frame_fetches_the_next_matching_frame
+    state = Mmtrix::Agent::TransactionState.tl_get
+    frame = @frame_stack.push_frame(state, :a,  0)
+
+    result = @frame_stack.fetch_matching_frame(frame)
+
+    assert_equal :a, result.tag
+    assert_equal frame, result
+  end
+
+  def test_fetch_matching_frame_discards_mismatched_frames
+    state = Mmtrix::Agent::TransactionState.tl_get
+    frame = @frame_stack.push_frame(state, :a,  0)
+    @frame_stack.push_frame(state, :b,  0)
+
+    result = @frame_stack.fetch_matching_frame(frame)
+
+    assert_equal :a, result.tag
+    assert_equal frame, result
+  end
+
+  def test_fetch_matching_frame_raises_an_error_if_no_match
+    state = Mmtrix::Agent::TransactionState.tl_get
+    frame = @frame_stack.push_frame(state, :a,  0)
+    @frame_stack.fetch_matching_frame(frame)
+
+    error = assert_raises(RuntimeError) do
+      @frame_stack.fetch_matching_frame(frame)
+    end
+
+    assert_match(/not found/, error.message)
+  end
+
+  def test_fetch_matching_frame_logs_any_unexpected_frame_tags
+    state = Mmtrix::Agent::TransactionState.tl_get
+    frame = @frame_stack.push_frame(state, :a,  0)
+    @frame_stack.push_frame(state, :unexpected,  0)
+
+    expects_logging(:info, includes("unexpected"))
+
+    @frame_stack.fetch_matching_frame(frame)
+  end
+
+  def assert_sampler_enabled_with(expected, opts={})
+    with_config(opts) do
+      assert_equal expected, @frame_stack.sampler_enabled?
+    end
+  end
+
+end
+