mmtrix_rpm 1.0.0.1

data/test/mmtrix/agent/rules_engine_test.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 File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class RulesEngineTest < Minitest::Test
+  def test_rule_defaults
+    rule = create_rule('match_expression' => '.*',
+                       'replacement'      => '*')
+    assert !rule.terminate_chain
+    assert !rule.each_segment
+    assert !rule.ignore
+    assert !rule.replace_all
+    assert_equal 0, rule.eval_order
+  end
+
+  def test_rule_applies_regex_rename
+    rule = create_rule('match_expression' => '[0-9]+',
+                       'replacement'      => '*')
+
+    input = 'foo/1/bar/22'
+
+    refute(rule.terminal?)
+    assert(rule.matches?(input))
+    assert_equal('foo/*/bar/22', rule.apply(input))
+  end
+
+  def test_rules_can_apply_to_frozen_strings
+    rule = create_rule('match_expression' => '[0-9]+',
+                       'replacement'      => '*')
+
+    input = 'foo/1/bar/22'.freeze
+
+    refute(rule.terminal?)
+    assert(rule.matches?(input))
+    assert_equal('foo/*/bar/22', rule.apply('foo/1/bar/22'.freeze))
+  end
+
+  def test_rule_applies_grouping_with_replacements
+    rule = create_rule('match_expression' => '([0-9]+)',
+                       'replacement'      => '\\1\\1')
+
+    input = 'foo/1/bar/22'
+
+    refute(rule.terminal?)
+    assert(rule.matches?(input))
+    assert_equal('foo/11/bar/22', rule.apply('foo/1/bar/22'))
+  end
+
+  def test_rule_renames_all_matches_when_replace_all_is_true
+    rule = create_rule('match_expression' => '[0-9]+',
+                       'replacement'      => '*',
+                       'replace_all'      => true)
+
+    refute(rule.terminal?)
+    assert(rule.matches?('foo/1/bar/22'))
+    assert_equal('foo/*/bar/*', rule.apply('foo/1/bar/22'))
+  end
+
+  def test_rule_with_no_match
+    rule = create_rule('match_expression' => 'QQ',
+                       'replacement'      => 'qq')
+
+    refute(rule.terminal?)
+    refute(rule.matches?('foo/1/bar/22'))
+    assert_equal('foo/1/bar/22', rule.apply('foo/1/bar/22'))
+  end
+
+  def test_applies_rules_in_order
+    rule = create_rule('match_expression' => '[0-9]+',
+                       'replacement'      => '*',
+                       'replace_all'      => true,
+                       'eval_order'       => 0)
+
+    rerule = create_rule('match_expression' => '\*',
+                         'replacement'      => 'x',
+                         'replace_all'      => true,
+                         'eval_order'       => 1)
+
+    engine = Mmtrix::Agent::RulesEngine.new([rerule, rule])
+
+    assert_equal('foo/x/bar/x', engine.rename('foo/1/bar/22'))
+  end
+
+  def test_can_apply_rules_to_all_segments
+    rule = create_rule('match_expression' => '[0-9]+.*',
+                       'replacement'      => '*',
+                       'each_segment'     => true)
+
+    engine = Mmtrix::Agent::RulesEngine.new([rule])
+
+    assert_equal('foo/*/bar/*', engine.rename('foo/1a/bar/22b'))
+  end
+
+  def test_stops_after_terminate_chain
+    rule0 = create_rule('match_expression' => '[0-9]+',
+                        'replacement'      => '*',
+                        'each_segment'     => true,
+                        'eval_order'       => 0,
+                        'terminate_chain'  => true)
+
+    rule1 = create_rule('match_expression' => '.*',
+                        'replacement'      => 'X',
+                        'replace_all'      => true,
+                        'eval_order'       => 1)
+
+    engine = Mmtrix::Agent::RulesEngine.new([rule0, rule1])
+
+    assert_equal('foo/*/bar/*', engine.rename('foo/1/bar/22'))
+  end
+
+  def create_rule(spec)
+    Mmtrix::Agent::RulesEngine::ReplacementRule.new(spec)
+  end
+
+  load_cross_agent_test('rules').each do |testcase|
+    define_method("test_#{testcase['testname']}") do
+      engine = Mmtrix::Agent::RulesEngine.create_metric_rules('metric_name_rules' => testcase['rules'])
+
+      testcase["tests"].each do |test|
+        assert_equal(test["expected"], engine.rename(test["input"]), "Input: #{test['input'].inspect}")
+      end
+    end
+  end
+
+  load_cross_agent_test('transaction_segment_terms').each do |testcase|
+    define_method("test_app_segment_terms_#{testcase['testname']}") do
+      engine = Mmtrix::Agent::RulesEngine.create_transaction_rules(testcase)
+      testcase['tests'].each do |test|
+        assert_equal(test["expected"], engine.rename(test["input"]), "Input: #{test['input'].inspect}")
+      end
+    end
+  end
+
+end

data/test/mmtrix/agent/sampled_buffer_test.rb

@@ -0,0 +1,106 @@
+# 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'
+
+module Mmtrix::Agent
+  class SampledBufferTest < Minitest::Test
+    include EventBufferTestCases
+
+    def buffer_class
+      SampledBuffer
+    end
+
+    def test_replaces_old_entries_when_necessary
+      buffer = buffer_class.new(5)
+
+      buffer.expects(:rand).with(6).returns(0)
+      buffer.expects(:rand).with(7).returns(1)
+      buffer.expects(:rand).with(8).returns(2)
+      buffer.expects(:rand).with(9).returns(3)
+      buffer.expects(:rand).with(10).returns(4)
+
+      10.times { |i| buffer << i }
+
+      assert_equal([5, 6, 7, 8, 9], buffer.to_a)
+    end
+
+    def test_discards_new_entries_when_necessary
+      buffer = buffer_class.new(5)
+
+      buffer.expects(:rand).with(6).returns(5)
+      buffer.expects(:rand).with(7).returns(6)
+      buffer.expects(:rand).with(8).returns(7)
+      buffer.expects(:rand).with(9).returns(8)
+      buffer.expects(:rand).with(10).returns(9)
+
+      10.times { |i| buffer << i }
+
+      assert_equal([0, 1, 2, 3, 4], buffer.to_a)
+    end
+
+    def test_append_returns_whether_item_was_stored
+      buffer = buffer_class.new(5)
+
+      buffer.expects(:rand).with(6).returns(5)
+
+      5.times do |i|
+        result = buffer.append(i)
+        assert(result)
+      end
+
+      result = buffer.append('foo')
+      refute(result)
+    end
+
+    # This test is non-deterministic: there is some (low) probability that it will
+    # fail. We repeatedly stream 10 items into a buffer of capacity 5, and verify
+    # that each item is included ~50% of the time.
+    #
+    # Because of the non-determinism, it is possible that we'll want to disable
+    # this test. That said, I've thus far been unsuccessful in making it fail, so
+    # I'm leaving it here for now.
+    def test_should_sample_evenly
+      buffer = buffer_class.new(5)
+      results = []
+
+      10000.times do
+        buffer.reset!
+        10.times { |i| buffer << i }
+        results << buffer.to_a
+      end
+
+      (0...10).each do |v|
+        num_results_including_v = results.select { |r| r.include?(v) }.size
+        assert_in_delta(0.5, num_results_including_v.to_f / results.size, 0.05)
+      end
+    end
+
+    def test_seen_lifetime_should_persist_across_resets
+      buffer = buffer_class.new(10)
+
+      100.times { |i| buffer << i }
+      buffer.reset!
+      assert_equal(100, buffer.seen_lifetime)
+
+      100.times { |i| buffer << i }
+      buffer.reset!
+      assert_equal(200, buffer.seen_lifetime)
+    end
+
+    def test_sample_rate_lifetime
+      buffer = buffer_class.new(10)
+      assert_equal(0, buffer.sample_rate_lifetime)
+
+      10.times { buffer << 'x' }
+      buffer.reset!
+      assert_equal(1.0, buffer.sample_rate_lifetime)
+
+      30.times { buffer << 'x' }
+      buffer.reset!
+      assert_equal(0.5, buffer.sample_rate_lifetime)
+    end
+  end
+end

data/test/mmtrix/agent/sampler_collection_test.rb

@@ -0,0 +1,90 @@
+# 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 SamplerCollectionTest < Minitest::Test
+
+  class DummySampler < Mmtrix::Agent::Sampler
+    named :dummy
+    def poll; end
+  end
+
+  class DummySampler2 < Mmtrix::Agent::Sampler
+    named :dummy2
+    def poll; end
+  end
+
+  def setup
+    @events     = Mmtrix::Agent::EventListener.new
+    @collection = Mmtrix::Agent::SamplerCollection.new(@events)
+  end
+
+  def test_add_sampler_adds_a_sampler_of_requested_class
+    @collection.add_sampler(DummySampler)
+    assert_equal(1, @collection.to_a.size)
+    assert_equal(DummySampler, @collection.to_a.first.class)
+  end
+
+  def test_add_sampler_does_add_non_dups
+    @collection.add_sampler(DummySampler)
+    @collection.add_sampler(DummySampler2)
+    assert_equal(2, @collection.to_a.size)
+    assert_equal([DummySampler, DummySampler2], @collection.map { |s| s.class })
+  end
+
+  def test_add_sampler_does_not_add_dups
+    @collection.add_sampler(DummySampler)
+    @collection.add_sampler(DummySampler)
+    assert_equal(1, @collection.to_a.size)
+  end
+
+  def test_add_sampler_omits_unsupported_samplers
+    DummySampler.stubs(:supported_on_this_platform?).returns(false)
+    @collection.add_sampler(DummySampler)
+    assert_equal(0, @collection.to_a.size)
+  end
+
+  def test_add_sampler_omits_disabled_samplers
+    with_config(:disable_dummy_sampler => true) do
+      @collection.add_sampler(DummySampler)
+      assert_equal(0, @collection.to_a.size)
+    end
+  end
+
+  def test_add_sampler_swallows_exceptions_during_sampler_creation
+    DummySampler.stubs(:new).raises(StandardError)
+    @collection.add_sampler(DummySampler)
+    assert_equal(0, @collection.to_a.size)
+  end
+
+  def test_add_sampler_calls_setup_events_with_event_listener_if_present
+    sampler = DummySampler.new
+    DummySampler.stubs(:new).returns(sampler)
+    sampler.expects(:setup_events).with(@events)
+    @collection.add_sampler(DummySampler)
+  end
+
+  def test_poll_samplers_polls_samplers
+    @collection.add_sampler(DummySampler)
+    @collection.add_sampler(DummySampler2)
+    @collection.each { |s| s.expects(:poll) }
+    @collection.poll_samplers
+  end
+
+  def test_poll_samplers_removes_busted_samplers_and_keeps_happy_ones
+    @collection.add_sampler(DummySampler)
+    @collection.add_sampler(DummySampler2)
+    good_sampler, bad_sampler = @collection.to_a
+    bad_sampler.stubs(:poll).raises('boo')
+    @collection.poll_samplers
+    assert_equal(1, @collection.to_a.size)
+    assert_equal([good_sampler], @collection.to_a)
+  end
+
+  def test_polls_samplers_on_before_harvest_event
+    @collection.expects(:poll_samplers)
+    @events.notify(:before_harvest)
+  end
+end

data/test/mmtrix/agent/sampler_test.rb

@@ -0,0 +1,66 @@
+# 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::SamplerTest < Minitest::Test
+  require 'mmtrix/agent/sampler'
+
+  class UnnamedSampler < Mmtrix::Agent::Sampler
+    def poll; end
+  end
+
+  class DummySampler < Mmtrix::Agent::Sampler
+    named :dummy
+
+    def poll; end
+  end
+
+  def test_inherited_should_append_subclasses_to_sampler_classes
+    test_class = Class.new(Mmtrix::Agent::Sampler)
+    sampler_classes = Mmtrix::Agent::Sampler.instance_eval { @sampler_classes }
+    assert(sampler_classes.include?(test_class), "Sampler classes (#{@sampler_classes.inspect}) does not include #{test_class.inspect}")
+    # cleanup the sampler created above
+    Mmtrix::Agent::Sampler.instance_eval { @sampler_classes.delete(test_class) }
+  end
+
+  def test_sampler_classes_should_be_an_array
+    sampler_classes = Mmtrix::Agent::Sampler.instance_variable_get('@sampler_classes')
+    assert(sampler_classes.is_a?(Array), 'Sampler classes should be saved as an array')
+    assert(sampler_classes.include?(Mmtrix::Agent::Samplers::CpuSampler), 'Sampler classes should include the CPU sampler')
+  end
+
+  def test_enabled_should_return_true_if_name_unknown
+    assert UnnamedSampler.enabled?
+  end
+
+  def test_initialize_should_accept_id_argument
+    UnnamedSampler.new(:larry)
+  end
+
+  def test_initialize_should_work_without_id_argument
+    UnnamedSampler.new
+  end
+
+  def test_initialize_should_set_id_from_passed_id
+    sampler = DummySampler.new(:larry)
+    assert_equal(:larry, sampler.id)
+  end
+
+  def test_initialize_should_set_id_from_name_if_no_passed_id
+    sampler = DummySampler.new
+    assert_equal(:dummy, sampler.id)
+  end
+
+  def test_enabled_should_return_false_if_disabled_via_config_setting
+    with_config(:disable_dummy_sampler => true) do
+      refute DummySampler.enabled?
+    end
+  end
+
+  def test_enabled_should_return_true_if_enabled_via_config_setting
+    with_config(:disable_dummy_sampler => false) do
+      assert DummySampler.enabled?
+    end
+  end
+end

data/test/mmtrix/agent/samplers/cpu_sampler_test.rb

@@ -0,0 +1,51 @@
+# -*- 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 File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'mmtrix/agent/samplers/cpu_sampler'
+
+class Mmtrix::Agent::Samplers::CpuSamplerTest < Minitest::Test
+
+  def setup
+    @original_jruby_version = JRUBY_VERSION if defined?(JRuby)
+  end
+
+  def teardown
+    set_jruby_version_constant(@original_jruby_version) if defined?(JRuby)
+  end
+
+  def test_correcly_detecting_jruby_support_for_correct_cpu_sampling
+    if defined?(JRuby)
+      set_jruby_version_constant '1.6.8'
+      refute_supported_on_platform
+
+      set_jruby_version_constant '1.7.0'
+      assert_supported_on_platform
+
+      set_jruby_version_constant '1.7.4'
+      assert_supported_on_platform
+    else
+      assert_supported_on_platform
+    end
+  end
+
+  #
+  # Helpers
+  #
+
+  def assert_supported_on_platform
+    assert_equal Mmtrix::Agent::Samplers::CpuSampler.supported_on_this_platform?, true, "should be supported on this platform"
+  end
+
+  def refute_supported_on_platform
+    assert_equal Mmtrix::Agent::Samplers::CpuSampler.supported_on_this_platform?, false, "should not be supported on this platform"
+  end
+
+  def set_jruby_version_constant(string)
+    Object.send(:remove_const, 'JRUBY_VERSION') if defined?(JRUBY_VERSION)
+    Object.const_set('JRUBY_VERSION', string)
+  end
+
+end