sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -0,0 +1,131 @@
+require 'timeout'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/agent/pipe_channel_manager'
+
+class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
+  def setup
+    @test_config = { :developer_mode => true }
+    NewRelic::Agent.config.apply_config(@test_config)
+    NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+    NewRelic::Agent.manual_start
+  end
+
+  def teardown
+    NewRelic::Agent::PipeChannelManager.listener.stop
+    NewRelic::Agent.shutdown
+    NewRelic::Agent.config.remove_config(@test_config)
+  end
+
+  def test_registering_a_pipe
+    NewRelic::Agent::PipeChannelManager.listener.wake.in.expects(:<<).with('.')
+    NewRelic::Agent::PipeChannelManager.register_report_channel(1)
+    pipe = NewRelic::Agent::PipeChannelManager.channels[1]
+
+    assert pipe.out.kind_of?(IO)
+    assert pipe.in.kind_of?(IO)
+
+    NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+  end
+
+  if NewRelic::LanguageSupport.can_fork? && !NewRelic::LanguageSupport.using_version?('1.9.1')
+    def test_listener_merges_timeslice_metrics
+      metric = 'Custom/test/method'
+      engine = NewRelic::Agent.agent.stats_engine
+      engine.get_stats_no_scope(metric).record_data_point(1.0)
+
+      listener = start_listener_with_pipe(666)
+
+      pid = Process.fork do
+        NewRelic::Agent.after_fork
+        new_engine = NewRelic::Agent::StatsEngine.new
+        new_engine.get_stats_no_scope(metric).record_data_point(2.0)
+        listener.pipes[666].write(:stats => new_engine.harvest_timeslice_data({}))
+      end
+      Process.wait(pid)
+      listener.stop
+
+      assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
+      engine.reset_stats
+    end
+
+    def test_listener_merges_transaction_traces
+      sampler = NewRelic::Agent.agent.transaction_sampler
+      TransactionSampleTestHelper.run_sample_trace_on(sampler)
+      NewRelic::Agent.agent.merge_data_from([nil, [sampler.samples], nil])
+
+      assert_equal(1, NewRelic::Agent.agent.unsent_traces_size)
+
+      listener = start_listener_with_pipe(667)
+
+      pid = Process.fork do
+        NewRelic::Agent.after_fork
+        new_sampler = NewRelic::Agent::TransactionSampler.new
+        sample = TransactionSampleTestHelper.run_sample_trace_on(new_sampler)
+        new_sampler.store_force_persist(sample)
+        with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+          listener.pipes[667].write(:transaction_traces => new_sampler.harvest([]))
+        end
+      end
+      Process.wait(pid)
+      listener.stop
+
+      assert_equal(2, NewRelic::Agent.agent.unsent_traces_size)
+    end
+
+    def test_listener_merges_error_traces
+      sampler = NewRelic::Agent.agent.error_collector
+      sampler.notice_error(Exception.new("message"), :uri => '/myurl/',
+                           :metric => 'path', :referer => 'test_referer',
+                           :request_params => {:x => 'y'})
+      NewRelic::Agent.agent.merge_data_from([nil, nil, sampler.errors])
+
+      assert_equal(1, NewRelic::Agent.agent.error_collector.errors.size)
+
+      listener = start_listener_with_pipe(668)
+
+      pid = Process.fork do
+        NewRelic::Agent.after_fork
+        new_sampler = NewRelic::Agent::ErrorCollector.new
+        new_sampler.notice_error(Exception.new("new message"), :uri => '/myurl/',
+                                 :metric => 'path', :referer => 'test_referer',
+                                 :request_params => {:x => 'y'})
+        listener.pipes[668].write(:error_traces => new_sampler.harvest_errors([]))
+      end
+      Process.wait(pid)
+      listener.stop
+
+      assert_equal(2, NewRelic::Agent.agent.error_collector.errors.size)
+    end
+
+    def test_close_pipe_on_EOF_string
+      listener = start_listener_with_pipe(669)
+
+      pid = Process.fork do
+        listener.pipes[669].write('EOF')
+      end
+      Process.wait(pid)
+      listener.stop
+
+      assert(!NewRelic::Agent::PipeChannelManager.channels[669] ||
+             NewRelic::Agent::PipeChannelManager.channels[669].closed?)
+    end
+
+    def test_manager_does_not_crash_when_given_bad_data
+      listener = start_listener_with_pipe(670)
+      assert_nothing_raised do
+        pid = Process.fork do
+          listener.pipes[670].in << 'some unloadable garbage'
+        end
+        Process.wait(pid)
+        listener.stop
+      end
+    end
+  end
+
+  def start_listener_with_pipe(pipe_id)
+    listener = NewRelic::Agent::PipeChannelManager.listener
+    listener.start
+    listener.register_pipe(pipe_id)
+    listener
+  end
+end

data/test/new_relic/agent/pipe_service_test.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+
+class PipeServiceTest < Test::Unit::TestCase
+  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
+    service = NewRelic::Agent::PipeService.new(:non_existant)
+    ::NewRelic::Agent.logger.expects(:error) \
+      .with(regexp_matches(/Unable to send data to parent process/)).once
+
+    assert_nothing_raised do
+      service.metric_data(Time.now, Time.now, {})
+    end
+  end
+
+  if NewRelic::LanguageSupport.can_fork? &&
+      !NewRelic::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(0.0, 0.1, metric_data0)
+      end
+
+      assert_equal 'Custom/something', received_data[:stats].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_traces]
+    end
+
+    def test_error_data
+      received_data = data_from_forked_process do
+        @service.error_data(['err'])
+      end
+      assert_equal ['err'], received_data[:error_traces]
+    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_traces]
+    end
+
+    def test_multiple_writes_to_pipe
+      pid = Process.fork do
+        metric_data0 = generate_metric_data('Custom/something')
+        @service.metric_data(0.0, 0.1, 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[:stats].keys.sort[0].name
+      assert_equal ['txn0'], received_data[:transaction_traces]
+      assert_equal ['err0'], received_data[:error_traces].sort
+    end
+
+    def test_shutdown_sends_EOF
+      received_data = data_from_forked_process do
+        @service.shutdown(Time.now)
+      end
+      assert_equal 'EOF', received_data[:EOF]
+    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.get_stats_no_scope(metric_name).record_data_point(data)
+    engine.harvest_timeslice_data({})
+  end
+
+  def read_from_pipe
+    pipe = NewRelic::Agent::PipeChannelManager.channels[:pipe_service_test]
+    pipe.in.close
+    data = {}
+    while payload = pipe.out.gets("\n\n")
+      got = Marshal.load(payload)
+      if got == 'EOF'
+        got = {:EOF => 'EOF'}
+      end
+      data.merge!(got)
+    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

@@ -0,0 +1,115 @@
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path('../../../test_helper', __FILE__)
+require File.expand_path('../../../test_contexts', __FILE__)
+
+class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::TestCase
+  extend TestContexts
+
+  attr_reader :agent
+
+  with_running_agent do
+    # Fake out the agent to think mongrel is running
+
+    should "agent_setup" do
+      assert NewRelic::Agent.instance.class == NewRelic::Agent::Agent
+      assert_raise RuntimeError do
+        NewRelic::Control.instance.init_plugin :agent_enabled => false
+      end
+    end
+
+    should "public_apis" do
+      assert_raise RuntimeError do
+        NewRelic::Agent.set_sql_obfuscator(:unknown) do |sql|
+          puts sql
+        end
+      end
+
+      ignore_called = false
+      NewRelic::Agent.ignore_error_filter do |e|
+        ignore_called = true
+        nil
+      end
+      NewRelic::Agent.notice_error(StandardError.new("message"), :request_params => {:x => "y"})
+      assert ignore_called
+      NewRelic::Agent.instance.error_collector.instance_variable_set '@ignore_filter', nil
+    end
+
+    should "startup_shutdown" do
+      with_config(:agent_enabled => true) do
+        @agent = NewRelic::Agent::ShimAgent.instance
+        @agent.shutdown
+        assert (not @agent.started?)
+        @agent.start
+        assert !@agent.started?
+        # this installs the real agent:
+        NewRelic::Agent.manual_start
+        @agent = NewRelic::Agent.instance
+        assert @agent != NewRelic::Agent::ShimAgent.instance
+        assert @agent.started?
+        @agent.shutdown
+        assert !@agent.started?
+        @agent.start
+        assert @agent.started?
+        NewRelic::Agent.shutdown
+      end
+    end
+
+    should "manual_start" do
+      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
+
+    should "post_fork_handler" do
+      NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+      NewRelic::Agent.after_fork
+      NewRelic::Agent.after_fork
+      NewRelic::Agent.shutdown
+    end
+    should "manual_overrides" do
+      NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
+      assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
+      assert_equal "mailer", NewRelic::Control.instance.local_env.dispatcher_instance_id
+      NewRelic::Agent.shutdown
+    end
+
+    should "restart" do
+      NewRelic::Agent.manual_start :app_name => "noapp", :dispatcher_instance_id => ""
+      NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
+      assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
+      assert_equal "mailer", NewRelic::Control.instance.local_env.dispatcher_instance_id
+      NewRelic::Agent.shutdown
+    end
+
+    should "set_record_sql" do
+      @agent.set_record_sql(false)
+      assert !NewRelic::Agent.is_sql_recorded?
+      NewRelic::Agent.disable_sql_recording do
+        assert_equal false, NewRelic::Agent.is_sql_recorded?
+        NewRelic::Agent.disable_sql_recording do
+          assert_equal false, NewRelic::Agent.is_sql_recorded?
+        end
+        assert_equal false, NewRelic::Agent.is_sql_recorded?
+      end
+      assert !NewRelic::Agent.is_sql_recorded?
+      @agent.set_record_sql(nil)
+    end
+
+    should "version" do
+      assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
+    end
+
+    context "with transaction api" do
+      should "reject empty arguments" do
+        assert_raises RuntimeError do
+          NewRelic::Agent.record_transaction 0.5
+        end
+      end
+      should "record a transaction" do
+        NewRelic::Agent.record_transaction 0.5, 'uri' => "/users/create?foo=bar"
+      end
+    end
+  end
+end

data/test/new_relic/agent/rules_engine_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class RulesEngineTest < Test::Unit::TestCase
+  def setup
+    @engine = NewRelic::Agent::RulesEngine.new
+  end
+
+  def test_rule_defaults
+    rule = NewRelic::Agent::RulesEngine::Rule.new('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 = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                  'replacement'      => '*')
+    assert_equal(['foo/*/bar/22', true], rule.apply('foo/1/bar/22'))
+  end
+
+  def test_rule_applies_grouping_with_replacements
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '([0-9]+)',
+                                                  'replacement'      => '\\1\\1')
+    assert_equal(['foo/11/bar/22', true], rule.apply('foo/1/bar/22'))
+  end
+
+  def test_rule_renames_all_matches_when_replace_all_is_true
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                  'replacement'      => '*',
+                                                  'replace_all'      => true)
+    assert_equal(['foo/*/bar/*', true], rule.apply('foo/1/bar/22'))
+  end
+
+  def test_rule_with_no_match
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => 'QQ',
+                                                  'replacement'      => 'qq')
+    assert_equal(['foo/1/bar/22', false], rule.apply('foo/1/bar/22'))
+  end
+
+  def test_applies_rules_in_order
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                  'replacement'      => '*',
+                                                  'replace_all'      => true,
+                                                  'eval_order'       => 0)
+    rerule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '\*',
+                                                    'replacement'      => 'x',
+                                                    'replace_all'      => true,
+                                                    'eval_order'       => 1)
+    @engine << rerule
+    @engine << rule
+
+    assert_equal('foo/x/bar/x', @engine.rename('foo/1/bar/22'))
+  end
+
+  def test_can_apply_rules_to_all_segments
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+.*',
+                                                  'replacement'      => '*',
+                                                  'each_segment'     => true)
+    @engine << rule
+
+    assert_equal('foo/*/bar/*', @engine.rename('foo/1a/bar/22b'))
+  end
+
+  def test_stops_after_terminate_chain
+    rule0 = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                   'replacement'      => '*',
+                                                   'each_segment'     => true,
+                                                   'eval_order'       => 0,
+                                                   'terminate_chain'  => true)
+    rule1 = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '.*',
+                                                   'replacement'      => 'X',
+                                                   'replace_all'      => true,
+                                                   'eval_order'       => 1)
+    @engine << rule0
+    @engine << rule1
+
+    assert_equal('foo/*/bar/*', @engine.rename('foo/1/bar/22'))
+  end
+end