mmtrix_rpm 1.0.0.1

data/test/mmtrix/agent/stats_test.rb

@@ -0,0 +1,189 @@
+# 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::StatsTest < Minitest::Test
+  def mock_plusequals(first, second, method, first_value, second_value)
+    first.expects(method).returns(first_value)
+    second.expects(method).returns(second_value)
+    first.expects("#{method}=".to_sym).with(first_value + second_value)
+  end
+
+  def test_update_totals
+    attrs = [:total_call_time, :total_exclusive_time, :sum_of_squares]
+    merged = setup_merge do |a, b|
+      attrs.each do |attr|
+        a.send("#{attr}=", 2)
+        b.send("#{attr}=", 3)
+      end
+    end
+    attrs.each do |attr|
+      assert_equal(5, merged.send(attr))
+    end
+  end
+
+  def setup_merge
+    a = Mmtrix::Agent::Stats.new
+    b = Mmtrix::Agent::Stats.new
+    a.reset
+    b.reset
+    yield a, b
+    a.merge(b)
+  end
+
+  def test_merge_expands_min_max_call_time
+    merged = setup_merge do |a, b|
+      a.call_count = 1
+      b.call_count = 1
+      a.min_call_time = 0.5
+      a.max_call_time = 3.0
+      b.min_call_time = 1.0
+      b.max_call_time = 4.0
+    end
+    assert_equal(0.5, merged.min_call_time)
+    assert_equal(4.0, merged.max_call_time)
+  end
+
+  def test_simple
+    stats = Mmtrix::Agent::Stats.new
+    validate stats, 0, 0, 0, 0
+
+    assert_equal stats.call_count,0
+    stats.trace_call 10
+    stats.trace_call 20
+    stats.trace_call 30
+
+    validate stats, 3, (10+20+30), 10, 30
+  end
+
+  def test_to_s
+    s1 = Mmtrix::Agent::Stats.new
+    s1.trace_call 10
+    assert_equal("[ 1 calls 10.0000s / 10.0000s ex]", s1.to_s)
+  end
+
+  def test_apdex_recording
+    s = Mmtrix::Agent::Stats.new
+
+    s.record_apdex(:apdex_s, 1)
+    s.record_apdex(:apdex_t, 1)
+
+    s.record_apdex(:apdex_f, 1)
+    s.record_apdex(:apdex_t, 1)
+
+    assert_equal(1, s.apdex_s)
+    assert_equal(1, s.apdex_f)
+    assert_equal(2, s.apdex_t)
+  end
+
+  def test_merge
+    s1 = Mmtrix::Agent::Stats.new
+    s2 = Mmtrix::Agent::Stats.new
+
+    s1.trace_call 10
+    s2.trace_call 20
+    s2.freeze
+
+    validate s2, 1, 20, 20, 20
+    s3 = s1.merge s2
+    validate s3, 2, (10+20), 10, 20
+    validate s1, 1, 10, 10, 10
+    validate s2, 1, 20, 20, 20
+
+    s1.merge! s2
+    validate s1, 2, (10+20), 10, 20
+    validate s2, 1, 20, 20, 20
+  end
+
+  def test_merge_with_exclusive
+    s1 = Mmtrix::Agent::Stats.new
+
+    s2 = Mmtrix::Agent::Stats.new
+
+    s1.trace_call 10, 5
+    s2.trace_call 20, 10
+    s2.freeze
+
+    validate s2, 1, 20, 20, 20, 10
+    s3 = s1.merge s2
+    validate s3, 2, (10+20), 10, 20, (10+5)
+    validate s1, 1, 10, 10, 10, 5
+    validate s2, 1, 20, 20, 20, 10
+
+    s1.merge! s2
+    validate s1, 2, (10+20), 10, 20, (5+10)
+    validate s2, 1, 20, 20, 20, 10
+  end
+
+  def test_freeze
+    s1 = Mmtrix::Agent::Stats.new
+
+    s1.trace_call 10
+    s1.freeze
+
+    begin
+      # the following should throw an exception because s1 is frozen
+      s1.trace_call 20
+      assert false
+    rescue StandardError
+      assert s1.frozen?
+      validate s1, 1, 10, 10, 10
+    end
+  end
+
+  def test_sum_of_squares_merge
+    s1 = Mmtrix::Agent::Stats.new
+    s1.trace_call 4
+    s1.trace_call 7
+
+    s2 = Mmtrix::Agent::Stats.new
+    s2.trace_call 13
+    s2.trace_call 16
+
+    s3 = s1.merge(s2)
+
+    assert_equal(s1.sum_of_squares, 4*4 + 7*7)
+    assert_equal(s3.sum_of_squares, 4*4 + 7*7 + 13*13 + 16*16, "check sum of squares")
+  end
+
+  def test_chained_stats_proxies_calls_to_scoped_and_unscoped
+    scoped_stats = Mmtrix::Agent::Stats.new
+    unscoped_stats = Mmtrix::Agent::Stats.new
+    chained_stats = Mmtrix::Agent::ChainedStats.new(scoped_stats, unscoped_stats)
+    chained_stats.record_data_point(42)
+    assert_equal(1, scoped_stats.call_count)
+    assert_equal(1, unscoped_stats.call_count)
+    assert_equal(42, scoped_stats.total_call_time)
+    assert_equal(42, unscoped_stats.total_call_time)
+  end
+
+  def test_chained_stats_returns_values_from_scoped
+    scoped_stats = Mmtrix::Agent::Stats.new
+    unscoped_stats = Mmtrix::Agent::Stats.new
+    chained_stats = Mmtrix::Agent::ChainedStats.new(scoped_stats, unscoped_stats)
+    scoped_stats.record_data_point(42)
+    assert_equal(1, chained_stats.call_count)
+    assert_equal(42, chained_stats.total_call_time)
+  end
+
+  if RUBY_VERSION >= '1.9'
+    def test_to_json_enforces_float_values
+      s1 = Mmtrix::Agent::Stats.new
+      s1.trace_call 3.to_r
+      s1.trace_call 7.to_r
+
+      assert_equal 3.0, JSON.load(s1.to_json)['min_call_time']
+    end
+  end
+
+  private
+  def validate (stats, count, total, min, max, exclusive = nil)
+    assert_equal count, stats.call_count
+    assert_equal total, stats.total_call_time
+    assert_equal min,   stats.min_call_time
+    assert_equal max,   stats.max_call_time
+    assert_equal exclusive, stats.total_exclusive_time if exclusive
+  end
+end

data/test/mmtrix/agent/synthetics_event_buffer_test.rb

@@ -0,0 +1,54 @@
+# 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 'test/mmtrix/agent/event_buffer_test_cases'
+require 'mmtrix/agent/synthetics_event_buffer'
+
+module Mmtrix::Agent
+  class SyntheticsEventBufferTest < Minitest::Test
+    include EventBufferTestCases
+
+    def buffer_class
+      SyntheticsEventBuffer
+    end
+
+    def create_event(timestamp)
+      [{"timestamp" => timestamp}, {}]
+    end
+
+    def test_append_with_reject_returns_rejected_item
+      buffer = buffer_class.new(5)
+
+      5.times do |i|
+        result, reject = buffer.append_with_reject(create_event(i))
+        refute_nil(result)
+        assert_nil(reject)
+      end
+
+      event = create_event(10)
+      result, reject = buffer.append_with_reject(event)
+
+      assert_nil result
+      assert_equal event, reject
+    end
+
+    def test_append_with_reject_bases_removal_on_timestamp
+      buffer = buffer_class.new(5)
+
+      last_event = nil
+      5.times do |i|
+        last_event = create_event(i + 10)
+        result = buffer.append(last_event)
+        assert(result)
+      end
+
+      event = create_event(1)
+      result, reject = buffer.append_with_reject(event)
+
+      assert_equal event, result
+      assert_equal last_event, reject
+    end
+  end
+end

data/test/mmtrix/agent/synthetics_monitor_test.rb

@@ -0,0 +1,93 @@
+# 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/synthetics_monitor'
+
+module Mmtrix::Agent
+  class SyntheticsMonitorTest < Minitest::Test
+    ENCODING_KEY_NOOP         = "\0"
+    TRUSTED_ACCOUNT_IDS       = [42,13]
+
+    VERSION_ID  = 1
+    ACCOUNT_ID  = 42
+    RESOURCE_ID = 100
+    JOB_ID      = 200
+    MONITOR_ID  = 300
+
+    BAD_ACCOUNT_ID = 7
+    BAD_VERSION_ID = 2
+
+    STANDARD_DATA = [ACCOUNT_ID, RESOURCE_ID, JOB_ID, MONITOR_ID]
+
+    def setup
+      @events  = EventListener.new
+      @monitor = SyntheticsMonitor.new(@events)
+
+      Mmtrix::Agent.reset_config
+      @config = {
+        :encoding_key        => ENCODING_KEY_NOOP,
+        :trusted_account_ids => TRUSTED_ACCOUNT_IDS
+      }
+      Mmtrix::Agent.config.add_config_for_testing(@config)
+
+      @events.notify(:finished_configuring)
+    end
+
+    def test_doesnt_record_synthetics_state_without_header
+      in_transaction do
+        @events.notify(:before_call, {})
+        assert_no_synthetics_payload
+      end
+    end
+
+    def test_doesnt_record_synthetics_if_incoming_request_higher_version
+      synthetics_payload = [BAD_VERSION_ID] + STANDARD_DATA
+      with_synthetics_headers(synthetics_payload) do
+        assert_no_synthetics_payload
+      end
+    end
+
+    def test_doesnt_record_synthetics_if_not_trusted_account
+      synthetics_payload = [VERSION_ID, BAD_ACCOUNT_ID] + STANDARD_DATA[1..-1]
+      with_synthetics_headers(synthetics_payload) do
+        assert_no_synthetics_payload
+      end
+    end
+
+    def test_doesnt_record_synthetics_if_data_too_short
+      synthetics_payload = [VERSION_ID, ACCOUNT_ID]
+      with_synthetics_headers(synthetics_payload) do
+        assert_no_synthetics_payload
+      end
+    end
+
+    def test_records_synthetics_state_from_header
+      key = SyntheticsMonitor::SYNTHETICS_HEADER_KEY
+      synthetics_payload = [VERSION_ID] + STANDARD_DATA
+      with_synthetics_headers(synthetics_payload, key) do
+        state = Mmtrix::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        assert_equal @last_encoded_header, txn.raw_synthetics_header
+        assert_equal synthetics_payload,   txn.synthetics_payload
+      end
+    end
+
+    def synthetics_header(payload, header_key = SyntheticsMonitor::SYNTHETICS_HEADER_KEY)
+      @last_encoded_header = json_dump_and_encode(payload)
+      { header_key => @last_encoded_header }
+    end
+
+    def assert_no_synthetics_payload
+      assert_nil Mmtrix::Agent::TransactionState.tl_get.current_transaction.synthetics_payload
+    end
+
+    def with_synthetics_headers(payload, header_key = SyntheticsMonitor::SYNTHETICS_HEADER_KEY)
+      in_transaction do
+        @events.notify(:before_call, synthetics_header(payload, header_key))
+        yield
+      end
+    end
+  end
+end

data/test/mmtrix/agent/system_info_test.rb

@@ -0,0 +1,119 @@
+# 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::SystemInfoTest < Minitest::Test
+  def setup
+    Mmtrix::Agent.instance.stats_engine.clear_stats
+    @sysinfo = ::Mmtrix::Agent::SystemInfo
+    @sysinfo.clear_processor_info
+  end
+
+  each_cross_agent_test :dir => 'proc_cpuinfo', :pattern => "*.txt" do |file|
+    if File.basename(file) =~ /^((\d+|X)pack_(\d+|X)core_(\d+|X)logical).txt$/
+      test_name = "test_#{$1}"
+
+      num_physical_packages  = $2.to_i
+      num_physical_cores     = $3.to_i
+      num_logical_processors = $4.to_i
+      num_physical_packages  = nil if num_physical_packages  < 1
+      num_physical_cores     = nil if num_physical_cores     < 1
+      num_logical_processors = nil if num_logical_processors < 1
+
+      define_method(test_name) do
+        cpuinfo = File.read(file)
+
+        info = @sysinfo.parse_cpuinfo(cpuinfo)
+
+        assert_equal(num_physical_packages , info[:num_physical_packages ])
+        assert_equal(num_physical_cores    , info[:num_physical_cores    ])
+        assert_equal(num_logical_processors, info[:num_logical_processors])
+      end
+    else
+      fail "Bad filename: cross_agent_tests/proc_cpuinfo/#{file}"
+    end
+  end
+
+  container_id_test_dir   = File.join(cross_agent_tests_dir, 'docker_container_id')
+  container_id_test_cases = load_cross_agent_test(File.join('docker_container_id', 'cases'))
+
+  container_id_test_cases.each do |test_case|
+    filename = test_case['filename']
+    basename = File.basename(filename, '.txt')
+    test_name = "test_container_id_#{basename}"
+
+    define_method(test_name) do
+      input = File.read(File.join(container_id_test_dir, filename))
+      container_id = @sysinfo.parse_docker_container_id(input)
+
+      message = "Parsed incorrect Docker container ID from #{filename}"
+      assert_equal(test_case['containerId'], container_id, message)
+
+      if test_case['expectedMetrics']
+        assert_metrics_recorded test_case['expectedMetrics']
+      else
+        refute_metrics_recorded "Supportability/utilization/docker/error"
+      end
+    end
+  end
+
+
+  each_cross_agent_test :dir => 'proc_meminfo', :pattern => '*.txt' do |file|
+    if File.basename(file) =~ /^meminfo_(\d+)MB.txt$/
+      test_name = "test_#{file}"
+
+      mem_total_expected = $1.to_f
+
+      define_method(test_name) do
+        meminfo = File.read(file)
+
+        mem_total_actual = @sysinfo.parse_linux_meminfo_in_mib(meminfo)
+
+        assert_equal(mem_total_expected, mem_total_actual)
+      end
+    else
+      fail "Bad filename: cross_agent_tests/proc_meminfo/#{file}"
+    end
+  end
+
+  def test_proc_meminfo_unparsable
+    assert_nil @sysinfo.parse_linux_meminfo_in_mib("")
+  end
+
+  def test_system_info_darwin_predicate
+    Mmtrix::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("darwin13")
+    assert Mmtrix::Agent::SystemInfo.darwin?, "Expected OS to match darwin"
+
+    Mmtrix::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
+    refute Mmtrix::Agent::SystemInfo.darwin?, "Did not expect OS to match darwin"
+  end
+
+  def test_system_info_linux_predicate
+    Mmtrix::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
+    assert Mmtrix::Agent::SystemInfo.linux?, "Expected OS to match linux"
+
+    Mmtrix::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("darwin13")
+    refute Mmtrix::Agent::SystemInfo.linux?, "Did not expect OS to match linux"
+  end
+
+  def test_system_info_bsd_predicate
+    Mmtrix::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("freebsd")
+    assert Mmtrix::Agent::SystemInfo.bsd?, "Expected OS to match bsd"
+
+    Mmtrix::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("darwin13")
+    refute Mmtrix::Agent::SystemInfo.bsd?, "Did not expect OS to match bsd"
+  end
+
+  def test_supportability_metric_recorded_when_docker_id_unavailable
+    Mmtrix::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
+    cgroup_info = File.read File.join(cross_agent_tests_dir, 'docker_container_id', 'invalid-length.txt')
+    Mmtrix::Agent::SystemInfo.expects(:proc_try_read).with('/proc/self/cgroup').returns(cgroup_info)
+    in_transaction('txn') do
+      assert_nil Mmtrix::Agent::SystemInfo.docker_container_id
+    end
+    assert_metrics_recorded "Supportability/utilization/docker/error"
+  end
+end
+

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

@@ -0,0 +1,149 @@
+# 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/agent_thread'
+
+module Mmtrix::Agent::Threading
+  class AgentThreadTest < Minitest::Test
+
+    def test_sets_label
+      t = AgentThread.create("labelled") {}
+      assert_equal "labelled", t[:mmtrix_label]
+      t.join
+    end
+
+    def test_bucket_thread_as_agent_when_profiling
+      t = AgentThread.create("labelled") {}
+      assert_equal :agent, AgentThread.bucket_thread(t, true)
+      t.join
+    end
+
+    def test_bucket_thread_as_agent_when_not_profiling
+      t = AgentThread.create("labelled") {}
+      assert_equal :ignore, AgentThread.bucket_thread(t, false)
+      t.join
+    end
+
+    def test_bucket_thread_as_request
+      q0 = Queue.new
+      q1 = Queue.new
+
+      t = Thread.new do
+        begin
+          in_web_transaction do
+            q0.push 'unblock main thread'
+            q1.pop
+          end
+        rescue => e
+          q0.push 'unblock main thread'
+          fail e
+        end
+      end
+
+      q0.pop # wait until thread has had a chance to start up
+      assert_equal :request, AgentThread.bucket_thread(t, DONT_CARE)
+
+      q1.push 'unblock background thread'
+      t.join
+    end
+
+    def test_bucket_thread_as_background
+      q0 = Queue.new
+      q1 = Queue.new
+
+      t = ::Thread.new do
+        begin
+          in_transaction do
+            q0.push 'unblock main thread'
+            q1.pop
+          end
+        rescue => e
+          q0.push 'unblock main thread'
+          fail e
+        end
+      end
+
+      q0.pop # wait until thread pushes to q
+      assert_equal :background, AgentThread.bucket_thread(t, DONT_CARE)
+
+      q1.push 'unblock background thread'
+      t.join
+    end
+
+    def test_bucket_thread_as_other
+      t = ::Thread.new {}
+      assert_equal :other, AgentThread.bucket_thread(t, DONT_CARE)
+      t.join
+    end
+
+    def test_runs_block
+      called = false
+
+      t = AgentThread.create("labelled") { called = true }
+      t.join
+
+      assert called
+    end
+
+    def test_standard_error_is_caught
+      expects_logging(:error, includes("exited"), any_parameters)
+
+      t = AgentThread.create("fail") { raise "O_o" }
+      t.join
+
+      assert_thread_completed(t)
+    end
+
+    def test_exception_is_reraised
+      expects_logging(:error, includes("exited"), any_parameters)
+
+      assert_raises(Exception) do
+        begin
+          t = AgentThread.create("fail") { raise Exception.new }
+          t.join
+        ensure
+          assert_thread_died_from_exception(t)
+        end
+      end
+    end
+
+    def assert_thread_completed(t)
+      assert_equal false, t.status
+    end
+
+    def assert_thread_died_from_exception(t)
+      assert_equal nil, t.status
+    end
+
+    TRACE = [
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/eventmachine-0.12.10/lib/eventmachine.rb:100:in `catch'",
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/mmtrix_rpm-3.5.3.452.dev/lib/mmtrix/agent/agent.rb:200:in `start_worker_thread'",
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/thin-1.5.0/lib/thin/backends/base.rb:300:in `block (3 levels) in run'",
+    ]
+
+    def test_scrubs_backtrace_when_not_profiling_agent_code
+      result = AgentThread.scrub_backtrace(stub(:backtrace => TRACE.dup), false)
+      assert_equal [TRACE[0], TRACE[2]], result
+    end
+
+    def test_doesnt_scrub_backtrace_when_profiling_agent_code
+      result = AgentThread.scrub_backtrace(stub(:backtrace => TRACE.dup), true)
+      assert_equal TRACE, result
+    end
+
+    def test_scrub_backtrace_handles_errors_during_backtrace
+      dummy_thread = stub
+      dummy_thread.stubs(:backtrace).raises(StandardError.new('nah'))
+      AgentThread.scrub_backtrace(dummy_thread, true)
+    end
+
+    def test_scrub_backtrace_handles_nil_backtrace
+      bt = AgentThread.scrub_backtrace(stub(:backtrace => nil), false)
+      assert_nil(bt)
+    end
+
+    DONT_CARE = true
+  end
+end