mmtrix_rpm 1.0.0.1

data/test/mmtrix/agent/mock_scope_listener.rb

@@ -0,0 +1,27 @@
+# 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 Mmtrix::Agent::MockScopeListener
+
+  attr_reader :scopes
+
+  def initialize
+    @scopes = []
+  end
+
+  def notice_push_frame(state, time)
+  end
+
+  def notice_pop_frame(state, scope, time)
+    @scopes << scope
+  end
+
+  def on_finishing_transaction(time)
+  end
+
+  def enabled?
+    true
+  end
+end

data/test/mmtrix/agent/obfuscator_test.rb

@@ -0,0 +1,77 @@
+# 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/obfuscator"
+
+class Mmtrix::Agent::ObfuscatorTest < Minitest::Test
+
+  OBFUSCATION_KEY = (1..40).to_a.pack('c*')
+  RUM_KEY_LENGTH  = 13
+
+  def setup
+    @config = { :license_key => OBFUSCATION_KEY }
+    Mmtrix::Agent.config.add_config_for_testing(@config)
+  end
+
+  def teardown
+    Mmtrix::Agent.config.remove_config(@config)
+    @obfuscator = nil
+  end
+
+  def obfuscator(length=nil)
+    @obfuscator ||= Mmtrix::Agent::Obfuscator.new(OBFUSCATION_KEY, length)
+  end
+
+  def test_obfuscate_basic
+    assert_encoded(RUM_KEY_LENGTH,
+                   'a happy piece of small text',
+                   'YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1')
+  end
+
+  def test_obfuscate_long_string
+    assert_encoded(RUM_KEY_LENGTH,
+                   'a happy piece of small text' * 5,
+                   'YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx')
+  end
+
+  def test_obfuscate_utf8
+    assert_encoded(RUM_KEY_LENGTH,
+                   "foooooééoooo - blah",
+                   "Z21sa2ppxKHKo2RjYm4iLiRnamZg")
+  end
+
+
+  def test_decoding_blank
+    obfuscator = Mmtrix::Agent::Obfuscator.new('query')
+    assert_equal "", obfuscator.deobfuscate("")
+  end
+
+  def test_decoding_empty_key
+    obfuscator = Mmtrix::Agent::Obfuscator.new("")
+    assert_equal "querty", obfuscator.encode('querty')
+  end
+
+  def test_encode_with_nil_uses_empty_key
+    obfuscator = Mmtrix::Agent::Obfuscator.new(nil)
+    assert_equal "querty", obfuscator.encode('querty')
+  end
+
+  def test_encoding_functions_can_roundtrip_utf8_text
+    str = 'Анастасі́я Олексі́ївна Каме́нських'
+    obfuscator = Mmtrix::Agent::Obfuscator.new('potap')
+    encoded = obfuscator.obfuscate(str)
+    decoded = obfuscator.deobfuscate(encoded)
+    decoded.force_encoding( 'utf-8' ) if decoded.respond_to?( :force_encoding )
+    assert_equal str, decoded
+  end
+
+  def assert_encoded(key_length, text, expected)
+    output = obfuscator(key_length).obfuscate(text)
+    assert_equal(expected, output)
+
+    unoutput = obfuscator.obfuscate(Base64.decode64(output))
+    assert_equal Base64.encode64(text).gsub("\n", ''), unoutput
+  end
+end

data/test/mmtrix/agent/parameter_filtering_test.rb

@@ -0,0 +1,39 @@
+# 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/parameter_filtering'
+
+module Mmtrix
+  module Agent
+    class ParameterFilteringTest < Minitest::Test
+
+      def test_apply_filters_returns_params_when_rails_is_not_present
+        undefine_constant(:"ActionDispatch::Http::ParameterFilter") do
+          params = {"password" => "mypass"}
+          result = ParameterFiltering.apply_filters({}, params)
+          assert_equal params, result
+        end
+      end
+
+      def test_apply_filters_replaces_file_uploads_with_placeholder
+        env = {"CONTENT_TYPE" => "multipart/form-data"}
+        params = {
+          :name => "name",
+          :file => {
+            :filename => "data.jpg",
+            :tempfile => "file_data"
+          }
+        }
+
+        expected = {:name => "name", :file => "[FILE]"}
+        result = ParameterFiltering.apply_filters(env, params)
+        assert_equal expected, result
+
+        # argument should not be mutated
+        assert_equal({ :filename => "data.jpg", :tempfile => "file_data" }, params[:file])
+      end
+    end
+  end
+end

data/test/mmtrix/agent/pipe_channel_manager_test.rb

@@ -0,0 +1,278 @@
+# 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 'timeout'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'mmtrix/agent/pipe_channel_manager'
+
+class Mmtrix::Agent::PipeChannelManagerTest < Minitest::Test
+  include TransactionSampleTestHelper
+
+  def setup
+    @test_config = { :monitor_mode => true }
+    Mmtrix::Agent.agent.drop_buffered_data
+    Mmtrix::Agent.config.add_config_for_testing(@test_config)
+
+    listener = Mmtrix::Agent::PipeChannelManager::Listener.new
+    Mmtrix::Agent::PipeChannelManager.instance_variable_set(:@listener, listener)
+
+    Mmtrix::Agent.manual_start
+    Mmtrix::Agent::TransactionState.tl_clear_for_testing
+  end
+
+  def teardown
+    Mmtrix::Agent::PipeChannelManager.listener.close_all_pipes
+    Mmtrix::Agent::PipeChannelManager.listener.stop
+    Mmtrix::Agent.shutdown
+    Mmtrix::Agent.config.remove_config(@test_config)
+  end
+
+  def test_registering_a_pipe
+    Mmtrix::Agent::PipeChannelManager.listener.wake.in.expects(:<<).with('.')
+    Mmtrix::Agent::PipeChannelManager.register_report_channel(1)
+    pipe = Mmtrix::Agent::PipeChannelManager.channels[1]
+
+    assert pipe.out.kind_of?(IO)
+    assert pipe.in.kind_of?(IO)
+
+    Mmtrix::Agent::PipeChannelManager.listener.close_all_pipes
+  end
+
+  if Mmtrix::LanguageSupport.can_fork? && !Mmtrix::LanguageSupport.using_version?('1.9.1')
+    def test_listener_merges_timeslice_metrics
+      metric = 'Custom/test/method'
+      engine = Mmtrix::Agent.agent.stats_engine
+      engine.get_stats_no_scope(metric).record_data_point(1.0)
+
+      start_listener_with_pipe(666)
+
+      run_child(666) do
+        Mmtrix::Agent.after_fork
+        new_engine = Mmtrix::Agent::StatsEngine.new
+        new_engine.get_stats_no_scope(metric).record_data_point(2.0)
+        service = Mmtrix::Agent::PipeService.new(666)
+        service.metric_data(new_engine.harvest!)
+      end
+
+      assert_metrics_recorded(metric => { :total_call_time => 3.0 })
+      engine.reset!
+    end
+
+    def test_listener_merges_transaction_traces
+      sampler = Mmtrix::Agent.agent.transaction_sampler
+      sample = run_sample_trace
+      assert_equal(1, sampler.count)
+
+      start_listener_with_pipe(667)
+      run_child(667) do
+        Mmtrix::Agent.after_fork
+        with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+          sample = run_sample_trace
+          service = Mmtrix::Agent::PipeService.new(667)
+          service.transaction_sample_data(sampler.harvest!)
+        end
+      end
+
+      assert_equal(2, sampler.count)
+    end
+
+    def test_listener_merges_error_traces
+      sampler = Mmtrix::Agent.agent.error_collector
+      sampler.notice_error(Exception.new("message"), :uri => '/myurl/',
+                           :metric => 'path', :referer => 'test_referer',
+                           :request_params => {:x => 'y'})
+      Mmtrix::Agent.agent.merge_data_for_endpoint(:error_data, sampler.errors)
+
+      assert_equal(1, Mmtrix::Agent.agent.error_collector.errors.size)
+
+      start_listener_with_pipe(668)
+
+      run_child(668) do
+        Mmtrix::Agent.after_fork
+        new_sampler = Mmtrix::Agent::ErrorCollector.new
+        new_sampler.notice_error(Exception.new("new message"), :uri => '/myurl/',
+                                 :metric => 'path', :referer => 'test_referer',
+                                 :request_params => {:x => 'y'})
+        service = Mmtrix::Agent::PipeService.new(668)
+        service.error_data(new_sampler.harvest!)
+      end
+
+      assert_equal(2, Mmtrix::Agent.agent.error_collector.errors.size)
+    end
+
+    def test_listener_merges_analytics_events
+      transaction_event_aggregator = Mmtrix::Agent.agent.instance_variable_get(:@transaction_event_aggregator)
+
+      start_listener_with_pipe(699)
+      Mmtrix::Agent.agent.stubs(:connected?).returns(true)
+      run_child(699) do
+        Mmtrix::Agent.after_fork(:report_to_channel => 699)
+        transaction_event_aggregator.on_transaction_finished({
+          :start_timestamp => Time.now,
+          :name => 'whatever',
+          :duration => 10,
+          :type => :controller
+        })
+        Mmtrix::Agent.agent.send(:transmit_event_data)
+      end
+
+      assert_equal(1, transaction_event_aggregator.samples.size)
+    end
+
+    def test_listener_merges_sql_traces
+      sampler = Mmtrix::Agent.agent.sql_sampler
+      create_sql_sample(sampler)
+
+      start_listener_with_pipe(667)
+      run_child(667) do
+        Mmtrix::Agent.after_fork
+        create_sql_sample(sampler)
+        service = Mmtrix::Agent::PipeService.new(667)
+        service.sql_trace_data(sampler.harvest!)
+      end
+
+      assert_equal(2, sampler.harvest!.size)
+    end
+
+    def test_close_pipe_on_child_explicit_close
+      listener = start_listener_with_pipe(669)
+      pid = Process.fork do
+        Mmtrix::Agent::PipeService.new(669)
+      end
+      Process.wait(pid)
+      listener.stop_listener_thread
+      assert_pipe_finished(669)
+    end
+
+    def test_close_pipe_on_child_exit
+      listener = start_listener_with_pipe(669)
+      pid = Process.fork do
+        Mmtrix::Agent::PipeService.new(669)
+        exit!
+      end
+      Process.wait(pid)
+      listener.stop_listener_thread
+      assert_pipe_finished(669)
+    end
+
+    def test_manager_does_not_crash_when_given_bad_data
+      listener = start_listener_with_pipe(670)
+      pid = Process.fork do
+        listener.pipes[670].in << 'some unloadable garbage'
+      end
+      Process.wait(pid)
+      listener.stop
+    end
+
+    def test_manager_does_not_crash_when_given_unmarshallable_junk
+      listener = start_listener_with_pipe(671)
+      expects_logging(:error, any_parameters)
+
+      pid = Process.fork do
+        listener.pipes[671].write("\x00")
+      end
+      Process.wait(pid)
+      listener.stop
+    end
+
+    def pipe_finished?(id)
+      (!Mmtrix::Agent::PipeChannelManager.channels[id] ||
+        Mmtrix::Agent::PipeChannelManager.channels[id].closed?)
+    end
+
+    def assert_pipe_finished(id)
+      assert(pipe_finished?(id),
+        "Expected pipe with ID #{id} to be nil or closed")
+    end
+
+    def create_sql_sample(sampler)
+      state = Mmtrix::Agent::TransactionState.tl_get
+      sampler.on_start_transaction(state, Time.now)
+      sampler.notice_sql("SELECT * FROM table", "ActiveRecord/Widgets/find", nil, 100, state)
+      sampler.on_finishing_transaction(state, 'noodles', Time.now)
+    end
+  end
+
+  def start_listener_with_pipe(pipe_id)
+    listener = Mmtrix::Agent::PipeChannelManager.listener
+    listener.start
+    listener.register_pipe(pipe_id)
+    listener
+  end
+
+  def test_pipe_read_length_failure
+    write_pipe = stub(:set_encoding => nil, :closed? => false, :close => nil)
+
+    # If we only read three bytes, it isn't valid.
+    # We can't tell whether any four bytes or more are a "good" length or not.
+    read_pipe = stub(:read => "jrc")
+    IO.stubs(:pipe).returns([read_pipe, write_pipe])
+
+    # Includes the failed bytes
+    expects_logging(:error, includes("[6a 72 63]"))
+
+    pipe = Mmtrix::Agent::PipeChannelManager::Pipe.new
+    assert_nil pipe.read
+  end
+
+  def test_pipe_read_length_nil_fails
+    write_pipe = stub(:set_encoding => nil, :closed? => false, :close => nil)
+
+    # No length at all returned on pipe, also a failure.
+    read_pipe = stub(:read => nil)
+    IO.stubs(:pipe).returns([read_pipe, write_pipe])
+
+    pipe = Mmtrix::Agent::PipeChannelManager::Pipe.new
+    assert_nil pipe.read
+  end
+
+  def test_listener_pipes_race_condition
+    # 1.8.7 doesn't have easy singleton_class access, but also doesn't have
+    # races thanks to green threads and the GIL, so pitch it!
+    return if RUBY_VERSION < "1.9.2"
+
+    begin
+      listener = Mmtrix::Agent::PipeChannelManager.listener
+      listener.instance_variable_set(:@select_timeout, 0.00001)
+      listener.start
+
+      listener.register_pipe(0)
+      pipe_out = listener.pipes[0].out
+
+      mutex = Mutex.new
+      mutex.lock
+      tried_to_close = false
+      pipe_out.singleton_class.send(:define_method, :closed?, Proc.new do
+        tried_to_close = true
+        mutex.synchronize do
+        end
+      end)
+
+      # Make sure we're actually paused in closed? call
+      until tried_to_close
+      end
+
+      t = Thread.new do
+        listener.register_pipe(1)
+      end
+
+      mutex.unlock
+      t.join
+    ensure
+      listener.close_all_pipes
+      listener.stop
+    end
+  end
+
+  def run_child(channel_id)
+    pid = Process.fork do
+      yield
+    end
+
+    Process.wait(pid)
+    until pipe_finished?(channel_id)
+      sleep 0.01
+    end
+  end
+end

data/test/mmtrix/agent/pipe_service_test.rb

@@ -0,0 +1,145 @@
+# 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 PipeServiceTest < Minitest::Test
+  def setup
+    Mmtrix::Agent::PipeChannelManager.listener.stop
+    Mmtrix::Agent::PipeChannelManager.register_report_channel(:pipe_service_test)
+    @service = Mmtrix::Agent::PipeService.new(:pipe_service_test)
+  end
+
+  def test_constructor
+    assert_equal :pipe_service_test, @service.channel_id
+  end
+
+  def test_connect_returns_nil
+    assert_nil @service.connect({})
+  end
+
+  # a #session method is required of services, though in the case of the
+  # PipeService all it does is invoke the block it's passed.
+  def test_session_invokes_block
+    block_ran = false
+    @service.session do
+      block_ran = true
+    end
+    assert(block_ran)
+  end
+
+  def test_write_to_missing_pipe_logs_error
+    ::Mmtrix::Agent.logger.expects(:error) \
+      .with(regexp_matches(/No communication channel to parent process/)).once
+    service = Mmtrix::Agent::PipeService.new(:non_existant)
+    service.metric_data({})
+  end
+
+  if Mmtrix::LanguageSupport.can_fork? &&
+      !Mmtrix::LanguageSupport.using_version?('1.9.1')
+
+    def test_metric_data
+      received_data = data_from_forked_process do
+        metric_data0 = generate_metric_data('Custom/something')
+        @service.metric_data(metric_data0)
+      end
+
+      assert_equal 'Custom/something', received_data[:metric_data].to_h.keys.sort[0].name
+    end
+
+    def test_transaction_sample_data
+      received_data = data_from_forked_process do
+        @service.transaction_sample_data(['txn'])
+      end
+
+      assert_equal ['txn'], received_data[:transaction_sample_data]
+    end
+
+    def test_error_data
+      received_data = data_from_forked_process do
+        @service.error_data(['err'])
+      end
+      assert_equal ['err'], received_data[:error_data]
+    end
+
+    def test_sql_trace_data
+      received_data = data_from_forked_process do
+        @service.sql_trace_data(['sql'])
+      end
+      assert_equal ['sql'], received_data[:sql_trace_data]
+    end
+
+    def test_analytic_event_data
+      received_data = data_from_forked_process do
+        @service.analytic_event_data(['events'])
+      end
+      assert_equal ['events'], received_data[:analytic_event_data]
+    end
+
+    def test_custom_event_data
+      received_data = data_from_forked_process do
+        @service.custom_event_data(['events'])
+      end
+      assert_equal ['events'], received_data[:custom_event_data]
+    end
+
+    def test_transaction_sample_data_with_newlines
+      payload_with_newline = "foo\n\nbar"
+      received_data = data_from_forked_process do
+        @service.transaction_sample_data([payload_with_newline])
+      end
+      assert_equal [payload_with_newline], received_data[:transaction_sample_data]
+    end
+
+    def test_multiple_writes_to_pipe
+      pid = Process.fork do
+        metric_data0 = generate_metric_data('Custom/something')
+        @service.metric_data(metric_data0)
+        @service.transaction_sample_data(['txn0'])
+        @service.error_data(['err0'])
+        @service.sql_trace_data(['sql0'])
+        @service.shutdown(Time.now)
+      end
+      Process.wait(pid)
+
+      received_data = read_from_pipe
+
+      assert_equal 'Custom/something', received_data[:metric_data].to_h.keys.sort[0].name
+      assert_equal ['txn0'], received_data[:transaction_sample_data]
+      assert_equal ['err0'], received_data[:error_data].sort
+    end
+
+    def test_shutdown_closes_pipe
+      data_from_forked_process do
+        @service.shutdown(Time.now)
+        assert Mmtrix::Agent::PipeChannelManager \
+          .channels[:pipe_service_test].closed?
+      end
+    end
+  end
+
+  def generate_metric_data(metric_name, data=1.0)
+    engine = Mmtrix::Agent::StatsEngine.new
+    engine.get_stats_no_scope(metric_name).record_data_point(data)
+    engine.harvest!
+  end
+
+  def read_from_pipe
+    pipe = Mmtrix::Agent::PipeChannelManager.channels[:pipe_service_test]
+    data = {}
+    while payload = pipe.read
+      endpoint, data_for_endpoint = Marshal.load(payload)
+      data.merge!(endpoint => data_for_endpoint)
+    end
+    data
+  end
+
+  def data_from_forked_process
+    pid = Process.fork do
+      yield
+    end
+    Process.wait(pid)
+    read_from_pipe
+  end
+end

data/test/mmtrix/agent/rpm_agent_test.rb

@@ -0,0 +1,94 @@
+# 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('../../../test_helper', __FILE__)
+
+class Mmtrix::Agent::RpmAgentTest < Minitest::Test
+  def setup
+    Mmtrix::Agent.manual_start
+    @agent = Mmtrix::Agent.instance
+    @agent.stubs(:start_worker_thread)
+  end
+
+  def teardown
+    Mmtrix::Agent.instance.shutdown
+  end
+
+  def test_public_apis
+    assert_raises(RuntimeError) do
+      Mmtrix::Agent.set_sql_obfuscator(:unknown) { |sql| puts sql }
+    end
+
+    ignore_called = false
+    filter = Proc.new do |e|
+      ignore_called = true
+      nil
+    end
+    with_ignore_error_filter(filter) do
+      Mmtrix::Agent.notice_error(StandardError.new("message"), :request_params => {:x => "y"})
+    end
+
+    assert(ignore_called)
+  end
+
+  def test_startup_shutdown_real
+    with_config(:agent_enabled => true, :monitor_mode => true) do
+      Mmtrix::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+      agent = Mmtrix::Agent.instance
+      assert agent.started?
+      agent.shutdown
+      refute agent.started?
+    end
+  end
+
+  def test_manual_start
+    Mmtrix::Agent.instance.expects(:connect).once
+    Mmtrix::Agent.instance.expects(:start_worker_thread).once
+    Mmtrix::Agent.instance.instance_variable_set '@started', nil
+    Mmtrix::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+    Mmtrix::Agent.shutdown
+  end
+
+  def test_post_fork_handler
+    Mmtrix::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+    Mmtrix::Agent.after_fork
+    Mmtrix::Agent.after_fork
+    Mmtrix::Agent.shutdown
+  end
+
+  def test_manual_overrides
+    Mmtrix::Agent.manual_start :app_name => "testjobs"
+    assert_equal "testjobs", Mmtrix::Agent.config.app_names[0]
+    Mmtrix::Agent.shutdown
+  end
+
+  def test_agent_restart
+    Mmtrix::Agent.manual_start :app_name => "noapp"
+    Mmtrix::Agent.manual_start :app_name => "testjobs"
+    assert_equal "testjobs", Mmtrix::Agent.config.app_names[0]
+    Mmtrix::Agent.shutdown
+  end
+
+  def test_set_record_sql
+    @agent.set_record_sql(false)
+    assert !Mmtrix::Agent.tl_is_sql_recorded?
+    Mmtrix::Agent.disable_sql_recording do
+      assert_equal false, Mmtrix::Agent.tl_is_sql_recorded?
+      Mmtrix::Agent.disable_sql_recording do
+        assert_equal false, Mmtrix::Agent.tl_is_sql_recorded?
+      end
+      assert_equal false, Mmtrix::Agent.tl_is_sql_recorded?
+    end
+    assert !Mmtrix::Agent.tl_is_sql_recorded?
+    @agent.set_record_sql(nil)
+  end
+
+  def test_agent_version_string
+    assert_match(/\d\.\d+\.\d+/, Mmtrix::VERSION::STRING)
+  end
+
+  def test_record_transaction
+    Mmtrix::Agent.record_transaction 0.5, 'uri' => "/users/create?foo=bar"
+  end
+end