RubyGems - newrelic_rpm - Versions diffs - 4.1.0.333 → 4.2.0.334 - Mend

newrelic_rpm 4.1.0.333 → 4.2.0.334

Files changed (788) hide show

data/test/new_relic/agent/pipe_service_test.rb DELETED Viewed

@@ -1,151 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
-class PipeServiceTest < Minitest::Test
-  def setup
-    NewRelic::Agent::PipeChannelManager.listener.stop
-    NewRelic::Agent::PipeChannelManager.register_report_channel(:pipe_service_test)
-    @service = NewRelic::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
-    ::NewRelic::Agent.logger.expects(:error) \
-      .with(regexp_matches(/No communication channel to parent process/)).once
-    service = NewRelic::Agent::PipeService.new(:non_existant)
-    service.metric_data({})
-  end
-  if NewRelic::LanguageSupport.can_fork?
-    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_error_event_data
-      received_data = data_from_forked_process do
-        @service.error_event_data(['err_ev'])
-      end
-      assert_equal ['err_ev'], received_data[:error_event_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 NewRelic::Agent::PipeChannelManager \
-          .channels[:pipe_service_test].closed?
-      end
-    end
-  end
-  def generate_metric_data(metric_name, data=1.0)
-    engine = NewRelic::Agent::StatsEngine.new
-    engine.tl_record_unscoped_metrics(metric_name, data)
-    engine.harvest!
-  end
-  def read_from_pipe
-    pipe = NewRelic::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/new_relic/agent/rpm_agent_test.rb DELETED Viewed

@@ -1,91 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require File.expand_path('../../../test_helper', __FILE__)
-class NewRelic::Agent::RpmAgentTest < Minitest::Test
-  def setup
-    NewRelic::Agent.manual_start
-    @agent = NewRelic::Agent.instance
-    @agent.stubs(:start_worker_thread)
-  end
-  def teardown
-    NewRelic::Agent.instance.shutdown
-    NewRelic::Agent.drop_buffered_data
-  end
-  def test_public_apis
-    assert_raises(RuntimeError) do
-      NewRelic::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
-      NewRelic::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
-      NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
-      agent = NewRelic::Agent.instance
-      assert agent.started?
-      agent.shutdown
-      refute agent.started?
-    end
-  end
-  def test_manual_start
-    NewRelic::Agent.instance.expects(:connect).once
-    NewRelic::Agent.instance.expects(:start_worker_thread).once
-    NewRelic::Agent.instance.instance_variable_set '@started', nil
-    NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
-    NewRelic::Agent.shutdown
-  end
-  def test_post_fork_handler
-    NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
-    NewRelic::Agent.after_fork
-    NewRelic::Agent.after_fork
-    NewRelic::Agent.shutdown
-  end
-  def test_manual_overrides
-    NewRelic::Agent.manual_start :app_name => "testjobs"
-    assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
-    NewRelic::Agent.shutdown
-  end
-  def test_agent_restart
-    NewRelic::Agent.manual_start :app_name => "noapp"
-    NewRelic::Agent.manual_start :app_name => "testjobs"
-    assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
-    NewRelic::Agent.shutdown
-  end
-  def test_set_record_sql
-    @agent.set_record_sql(false)
-    assert !NewRelic::Agent.tl_is_sql_recorded?
-    NewRelic::Agent.disable_sql_recording do
-      assert_equal false, NewRelic::Agent.tl_is_sql_recorded?
-      NewRelic::Agent.disable_sql_recording do
-        assert_equal false, NewRelic::Agent.tl_is_sql_recorded?
-      end
-      assert_equal false, NewRelic::Agent.tl_is_sql_recorded?
-    end
-    assert !NewRelic::Agent.tl_is_sql_recorded?
-    @agent.set_record_sql(nil)
-  end
-  def test_agent_version_string
-    assert_match(/\d\.\d+\.\d+/, NewRelic::VERSION::STRING)
-  end
-end

data/test/new_relic/agent/rules_engine_test.rb DELETED Viewed

@@ -1,136 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/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 = NewRelic::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 = NewRelic::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 = NewRelic::Agent::RulesEngine.new([rule0, rule1])
-    assert_equal('foo/*/bar/*', engine.rename('foo/1/bar/22'))
-  end
-  def create_rule(spec)
-    NewRelic::Agent::RulesEngine::ReplacementRule.new(spec)
-  end
-  load_cross_agent_test('rules').each do |testcase|
-    define_method("test_#{testcase['testname']}") do
-      engine = NewRelic::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 = NewRelic::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/new_relic/agent/sampled_buffer_test.rb DELETED Viewed

@@ -1,142 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require File.expand_path '../../../test_helper', __FILE__
-require 'new_relic/agent/event_buffer_test_cases'
-module NewRelic::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
-    def test_append_with_block
-      buffer = buffer_class.new(5)
-      5.times do |i|
-        buffer.append { i }
-      end
-      assert_equal [0, 1, 2, 3, 4], buffer.to_a
-    end
-    def test_append_with_block_while_sampling
-      buffer = buffer_class.new(5)
-      buffer.stubs(:rand).returns(0)
-      10.times do |i|
-        buffer.append { i }
-      end
-      assert_equal [9, 1, 2, 3, 4], buffer.to_a
-    end
-    def test_append_with_block_increments_seen
-      buffer = buffer_class.new(5)
-      10.times do |i|
-        buffer.append { i }
-      end
-      assert_equal 10, buffer.num_seen
-    end
-    def test_append_does_not_allow_an_argument_and_block
-      assert_raises ArgumentError do
-        buffer = buffer_class.new 5
-        buffer.append(4) { 5 }
-      end
-    end
-  end
-end