sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/agent/thread_test.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/thread'
+
+class ThreadTest < Test::Unit::TestCase
+
+  def test_sets_label
+    t = NewRelic::Agent::AgentThread.new("labelled") {}
+    assert_equal "labelled", t[:newrelic_label]
+  end
+
+  def test_bucket_thread_as_agent_when_profiling
+    t = NewRelic::Agent::AgentThread.new("labelled") {}
+    assert_equal :agent, NewRelic::Agent::AgentThread.bucket_thread(t, true)
+  end
+
+  def test_bucket_thread_as_agent_when_not_profiling
+    t = NewRelic::Agent::AgentThread.new("labelled") {}
+    assert_equal :ignore, NewRelic::Agent::AgentThread.bucket_thread(t, false)
+  end
+
+  def test_bucket_thread_as_request
+    t = ::Thread.new {}
+    frame = NewRelic::Agent::Instrumentation::MetricFrame.new
+    frame.request = "has a request"
+    t[:newrelic_metric_frame] = frame
+
+    assert_equal :request, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_bucket_thread_as_background
+    t = ::Thread.new {}
+    frame = NewRelic::Agent::Instrumentation::MetricFrame.new
+    t[:newrelic_metric_frame] = frame
+
+    assert_equal :background, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_bucket_thread_as_other_if_nil_frame
+    t = ::Thread.new {}
+    t[:newrelic_metric_frame] = nil
+
+    assert_equal :other, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_bucket_thread_as_other
+    t = ::Thread.new {}
+    assert_equal :other, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
+  end
+
+  def test_runs_block
+    called = false
+
+    t = NewRelic::Agent::AgentThread.new("labelled") { called = true }
+    t.join
+
+    assert called
+  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/newrelic_rpm-3.5.3.452.dev/lib/new_relic/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 = NewRelic::Agent::AgentThread.scrub_backtrace(stub(:backtrace => TRACE), false)
+    assert_equal [TRACE[0], TRACE[2]], result
+  end
+
+  def test_doesnt_scrub_backtrace_when_profiling_agent_code
+    result = NewRelic::Agent::AgentThread.scrub_backtrace(stub(:backtrace => TRACE), 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'))
+    assert_nothing_raised do
+      NewRelic::Agent::AgentThread.scrub_backtrace(dummy_thread, true)
+    end
+  end
+
+  def test_scrub_backtrace_handles_nil_backtrace
+    bt = NewRelic::Agent::AgentThread.scrub_backtrace(stub(:backtrace => nil), false)
+    assert_nil(bt)
+  end
+
+  DONT_CARE = true
+end

data/test/new_relic/agent/threaded_test.rb

@@ -0,0 +1,65 @@
+class ThreadedTest < Test::Unit::TestCase
+  def setup
+    @original_thread_class = NewRelic::Agent::AgentThread
+    swap_thread_class(FakeThread)
+  end
+
+  def teardown
+    swap_thread_class(@original_thread_class)
+    @original_thread_class = nil
+
+    FakeThread.list.clear
+  end
+
+  def default_test
+    # no-op to keep quiet....
+  end
+
+  private
+
+  def swap_thread_class(klass)
+    NewRelic::Agent.send(:remove_const, "AgentThread") if NewRelic::Agent.const_defined?("AgentThread")
+    NewRelic::Agent.const_set("AgentThread", klass)
+  end
+end
+
+class FakeThread
+  @@list = []
+
+  def initialize(locals={}, &block)
+    @locals = locals
+    yield if block_given?
+  end
+
+  def self.current
+    {}
+  end
+
+  def self.list
+    @@list
+  end
+
+  def self.bucket_thread(thread, _)
+    thread[:bucket] 
+  end
+
+  def self.scrub_backtrace(thread, _)
+    thread[:scrubbed_backtrace] || thread.backtrace
+  end
+
+  def key?(key)
+    @locals.key?(key)
+  end
+
+  def [](key)
+    @locals[key]
+  end
+
+  def backtrace
+    @locals[:backtrace] || []
+  end
+
+  def join
+  end
+end
+

data/test/new_relic/agent/transaction_info_test.rb

@@ -0,0 +1,106 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'ostruct'
+
+class NewRelic::Agent::TransactionInfoTest < Test::Unit::TestCase
+  def setup
+    @request = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=12345678'})
+    @request_with_embedded_tag = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=1234<tag>evil</tag>5678'})
+    @request_with_embedded_utf8_encoded_js = OpenStruct.new(:cookies => {'NRAGENT' => "tk=1234&#34&#93&#41&#595678"})
+    @request_with_double_quotes = OpenStruct.new(:cookies => {'NRAGENT' => 'tk="""deadbeef"""'})
+    @request_with_single_quotes = OpenStruct.new(:cookies => {'NRAGENT' => "tk='''deadbeef'''"})
+    @request_with_multi_lt = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=<<<deadbeef'})
+    @request_with_multi_gt = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=>>>deadbeef'})
+    @request_with_bare_token = OpenStruct.new(:cookies => {'NRAGENT' => 0xdeadbeef})
+    @request_with_nil_token = OpenStruct.new(:cookies => {'NRAGENT' => nil})
+  end
+
+  def test_get_token_safe_token_returned_untouched
+    assert_equal("12345678", NewRelic::Agent::TransactionInfo.get_token(@request))
+  end
+
+  def test_get_token_with_embedded_tags_sanitized
+    assert_equal("",NewRelic::Agent::TransactionInfo.get_token(@request_with_embedded_tag))
+  end
+
+  def test_get_token_with_embedded_utf8_js_sanitized
+    assert_equal("1234&amp;#34&amp;#93&amp;#41&amp;#595678",
+                 NewRelic::Agent::TransactionInfo.get_token(@request_with_embedded_utf8_encoded_js))
+  end
+
+  def test_get_token_replaces_double_quoted_token_with_empty_string
+    assert_equal("", NewRelic::Agent::TransactionInfo.get_token(@request_with_double_quotes))
+  end
+
+  def test_get_token_replaces_single_quoted_toket_with_empty_string
+    assert_equal("", NewRelic::Agent::TransactionInfo.get_token(@request_with_single_quotes))
+  end
+
+  def test_get_token_replaces_token_started_with_multiple_Lt_with_empty_string
+    assert_equal("", NewRelic::Agent::TransactionInfo.get_token(@request_with_multi_lt))
+  end
+
+  def test_get_token_replaces_token_started_with_multiple_gt_with_empty_string
+    assert_equal("", NewRelic::Agent::TransactionInfo.get_token(@request_with_multi_gt))
+  end
+
+  def test_get_token_bare_value_replaced_with_nil
+    assert_equal(nil,NewRelic::Agent::TransactionInfo.get_token(@request_with_bare_token))
+  end
+
+  def test_get_token_nil_token_returns_nil_token
+    assert_equal(nil,NewRelic::Agent::TransactionInfo.get_token(@request_with_ni_token))
+  end
+
+  def test_has_correct_apdex_t_for_tansaction
+    txn_info = NewRelic::Agent::TransactionInfo.get
+    config = { :web_transactions_apdex => {'Controller/foo/bar' => 1.5},
+      :apdex_t => 2.0 }
+
+    with_config(config, :do_not_cast => true) do
+      txn_info.transaction_name = 'Controller/foo/bar'
+      assert_equal 1.5, txn_info.apdex_t
+      txn_info.transaction_name = 'Controller/some/other/txn'
+      assert_equal 2.0, txn_info.apdex_t
+    end
+  end
+
+  def test_has_correct_transaction_trace_threshold_when_default
+    txn_info = NewRelic::Agent::TransactionInfo.get
+    config = { :web_transactions_apdex => {'Controller/foo/bar' => 1.5},
+      :apdex_t => 2.0 }
+
+    with_config(config, :do_not_cast => true) do
+      txn_info.transaction_name = 'Controller/foo/bar'
+      assert_equal 6.0, txn_info.transaction_trace_threshold
+      txn_info.transaction_name = 'Controller/some/other/txn'
+      assert_equal 8.0, txn_info.transaction_trace_threshold
+    end
+  end
+
+  def test_has_correct_transaction_trace_threshold_when_specified
+    txn_info = NewRelic::Agent::TransactionInfo.get
+    config = {
+      :web_transactions_apdex => {'Controller/foo/bar' => 1.5},
+      :apdex_t => 2.0,
+      :'transaction_tracer.transaction_threshold' => 4.0
+    }
+
+    with_config(config, :do_not_cast => true) do
+      txn_info.transaction_name = 'Controller/foo/bar'
+      assert_equal 4.0, txn_info.transaction_trace_threshold
+      txn_info.transaction_name = 'Controller/some/other/txn'
+      assert_equal 4.0, txn_info.transaction_trace_threshold
+    end
+  end
+
+  def test_transaction_name
+    NewRelic::Agent::TransactionInfo.reset
+    txn = NewRelic::Agent::TransactionInfo.get
+    assert_equal(NewRelic::Agent::TransactionInfo::DEFAULT_TRANSACTION_NAME,
+      txn.transaction_name)
+    assert_equal(false, txn.transaction_name_set?)
+    txn.transaction_name = "foobar"
+    assert_equal("foobar", txn.transaction_name)
+    assert_equal(true, txn.transaction_name_set?)
+  end
+end

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -0,0 +1,227 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
+
+  def setup
+    @builder = NewRelic::Agent::TransactionSampleBuilder.new
+  end
+
+  # if it doesn't the core app tests will break.  Not strictly necessary but
+  # we'll enforce it with this test for now.
+  def test_trace_entry_returns_segment
+    segment = @builder.trace_entry("/Foo/Bar", Time.now)
+    assert segment, "Segment should not be nil"
+    assert segment.is_a?(NewRelic::TransactionSample::Segment), "Segment should not be a #{segment.class.name}"
+  end
+
+  def test_build_sample
+    build_segment("a") do
+      build_segment("aa") do
+        build_segment("aaa")
+      end
+      build_segment("ab") do
+        build_segment("aba") do
+          build_segment("abaa")
+        end
+        build_segment("aba")
+        build_segment("abc") do
+          build_segment("abca")
+          build_segment("abcd")
+        end
+      end
+    end
+    build_segment "b"
+    build_segment "c" do
+      build_segment "ca"
+      build_segment "cb" do
+        build_segment "cba"
+      end
+    end
+
+    @builder.finish_trace(Time.now.to_f)
+    validate_builder
+  end
+
+  def test_freeze
+    build_segment "a" do
+      build_segment "aa"
+    end
+
+    begin
+      builder.sample
+      assert false
+    rescue => e
+      # expected
+    end
+
+    @builder.finish_trace(Time.now.to_f)
+
+    validate_builder
+
+    begin
+      build_segment "b"
+      assert false
+    rescue TypeError => e
+      # expected
+    end
+  end
+
+  # this is really a test for transaction sample
+  def test_omit_segments_with
+    build_segment "Controller/my_controller/index" do
+      sleep 0.010
+
+      build_segment "Rails/Application Code Loading" do
+        sleep 0.020
+
+        build_segment "foo/bar" do
+          sleep 0.010
+        end
+      end
+
+      build_segment "a" do
+        build_segment "ab"
+        sleep 0.010
+      end
+      build_segment "b" do
+        build_segment "ba"
+        sleep 0.05
+        build_segment "bb"
+        build_segment "bc" do
+          build_segment "bca"
+          sleep 0.05
+        end
+      end
+      build_segment "c"
+    end
+    @builder.finish_trace(Time.now.to_f)
+
+    validate_builder false
+
+    sample = @builder.sample
+
+    should_be_a_copy = sample.omit_segments_with('OMIT NOTHING')
+    validate_segment should_be_a_copy.root_segment, false
+
+    assert_equal sample.params, should_be_a_copy.params
+    assert_equal(sample.root_segment.to_debug_str(0),
+                 should_be_a_copy.root_segment.to_debug_str(0))
+
+    without_code_loading = sample.omit_segments_with('Rails/Application Code Loading')
+    validate_segment without_code_loading.root_segment, false
+
+    # after we take out code loading, the delta should be approximately
+    # 30 milliseconds
+    delta = (sample.duration - without_code_loading.duration) * 1000
+
+    # Need to allow substantial headroom on the upper bound to prevent
+    # spurious errors.
+    assert delta >= 28, "delta #{delta} should be between 28 and 100"
+    # disable this test for a couple days:
+    assert delta <= 100, "delta #{delta} should be between 28 and 100"
+
+    # ensure none of the segments have this regex
+    without_code_loading.each_segment do |segment|
+      assert_nil segment.metric_name =~ /Rails\/Application Code Loading/
+    end
+  end
+  def test_unbalanced_handling
+    assert_raise RuntimeError do
+      build_segment("a") do
+        begin
+          build_segment("aa") do
+            build_segment("aaa") do
+              raise "a problem"
+            end
+          end
+          rescue; end
+      end
+    end
+  end
+  def test_marshal
+    build_segment "a" do
+      build_segment "ab"
+    end
+    build_segment "b" do
+      build_segment "ba"
+      build_segment "bb"
+      build_segment "bc" do
+        build_segment "bca"
+      end
+    end
+    build_segment "c"
+
+    @builder.finish_trace(Time.now.to_f)
+    validate_builder
+
+    dump = Marshal.dump @builder.sample
+    sample = Marshal.restore(dump)
+    validate_segment(sample.root_segment)
+  end
+
+  def test_parallel_first_level_segments
+    build_segment "a" do
+      build_segment "ab"
+    end
+    build_segment "b"
+    build_segment "c"
+
+    @builder.finish_trace(Time.now.to_f)
+    validate_builder
+  end
+
+  def test_trace_should_not_record_more_than_segment_limit
+    with_config(:'transaction_tracer.limit_segments' => 3) do
+      8.times {|i| build_segment i.to_s }
+      assert_equal 3, @builder.sample.count_segments
+    end
+  end
+
+  def test_finish_trace_records_threshold
+    NewRelic::Agent::TransactionInfo.get.stubs(:transaction_trace_threshold) \
+      .returns(2.0)
+    @builder.finish_trace
+    assert_equal 2.0, @builder.sample.threshold
+  end
+
+  # regression
+  def test_trace_should_log_segment_reached_once
+    with_config(:'transaction_tracer.limit_segments' => 3) do
+      expects_logging(:debug, includes("Segment limit"))
+      8.times {|i| build_segment i.to_s }
+    end
+  end
+
+  def validate_builder(check_names = true)
+    validate_segment @builder.sample.root_segment, check_names
+  end
+
+  def validate_segment(s, check_names = true)
+    p = s.parent_segment
+
+    unless p.nil? || p.metric_name == 'ROOT'
+      assert p.called_segments.include?(s)
+      assert_equal p.metric_name.length, s.metric_name.length - 1, "p: #{p.metric_name}, s: #{s.metric_name}" if check_names
+      assert p.metric_name < s.metric_name if check_names
+      assert p.entry_timestamp <= s.entry_timestamp
+    end
+
+    assert s.exit_timestamp >= s.entry_timestamp
+
+    children = s.called_segments
+    last_segment = s
+    children.each do |child|
+      assert child.metric_name > last_segment.metric_name if check_names
+      assert child.entry_timestamp >= last_segment.entry_timestamp
+      last_metric = child
+
+      validate_segment(child, check_names)
+    end
+  end
+
+  def build_segment(metric, time = 0, &proc)
+    @builder.trace_entry(metric, Time.now.to_f)
+    proc.call if proc
+    @builder.trace_exit(metric, Time.now.to_f)
+  end
+end