newrelic_rpm 3.11.2.286 → 3.12.0.288

data/test/new_relic/transaction_sample/summary_segment_test.rb

@@ -1,34 +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'))
-require 'new_relic/transaction_sample/summary_segment'
-class NewRelic::TransactionSample::SummarySegmentTest < Minitest::Test
-  def test_summary_segment_creation
-    fake_segment = mock_segment
-    NewRelic::TransactionSample::SummarySegment.new(fake_segment)
-  end
-
-  def test_add_segments
-    fake_segment = mock_segment
-    ss = NewRelic::TransactionSample::SummarySegment.new(fake_segment)
-    other_fake_segment = mock_segment
-    # with the new summary segment
-    ss.expects(:add_called_segment).with(instance_of(NewRelic::TransactionSample::SummarySegment))
-    ss.add_segments([other_fake_segment])
-  end
-
-  private
-
-  @@seg_count = 0
-  def mock_segment
-    @@seg_count += 1
-    segment = mock('segment ' + @@seg_count.to_s)
-    segment.expects(:entry_timestamp).returns(Time.now)
-    segment.expects(:exit_timestamp).returns(Time.now)
-    segment.expects(:metric_name).returns('Custom/test/metric')
-    segment.expects(:called_segments).returns([])
-    segment
-  end
-end

data/test/new_relic/transaction_sample_subtest_test.rb

@@ -1,41 +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.
-
-class NewRelic::TransactionSample::SubTest < Minitest::Test
-  def setup
-    @t = NewRelic::TransactionSample.new
-
-    @t.params[:test] = "hi"
-
-    s1 = @t.create_segment(1.0, "controller")
-
-    @t.root_segment.add_called_segment(s1)
-
-    s2 = @t.create_segment(2.0, "AR1")
-
-    s2.params[:test] = "test"
-
-    s1.add_called_segment(s2)
-    s2.end_trace 3.0
-    s1.end_trace 4.0
-
-    s3 = @t.create_segment(4.0, "post_filter")
-    @t.root_segment.add_called_segment(s3)
-    s3.end_trace 6.0
-
-    s4 = @t.create_segment(6.0, "post_filter")
-    @t.root_segment.add_called_segment(s4)
-    s4.end_trace 7.0
-  end
-
-  def test_exclusive_duration
-    s1 = @t.root_segment.called_segments.first
-    assert_equal 3.0, s1.duration
-    assert_equal 2.0, s1.exclusive_duration
-  end
-
-  def test_count_the_segments
-    assert_equal 4, @t.count_segments
-  end
-end

data/test/new_relic/transaction_sample_test.rb

@@ -1,361 +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.rb', __FILE__)
-require 'new_relic/rack/developer_mode'
-
-class NewRelic::TransactionSampleTest < Minitest::Test
-  include TransactionSampleTestHelper
-
-  ::SQL_STATEMENT = "SELECT * from sandwiches WHERE meat='bacon'"
-  ::OBFUSCATED_SQL_STATEMENT = "SELECT * from sandwiches WHERE meat=?"
-
-  FORCE_PERSIST_POSITION = 7
-  SYNTHETICS_POSITION    = 9
-
-  def setup
-    @test_config = { :developer_mode => true }
-    NewRelic::Agent.config.add_config_for_testing(@test_config)
-
-    NewRelic::Agent.agent.transaction_sampler.reset!
-
-    @connection_stub = Mocha::Mockery.instance.named_mock('connection')
-    @connection_stub.stubs(:execute).returns(dummy_mysql_explain_result({'foo' => 'bar'}))
-
-    NewRelic::Agent::Database.stubs(:get_connection).returns @connection_stub
-    @t = make_sql_transaction(::SQL_STATEMENT)
-
-    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
-      @marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-    else
-      @marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
-    end
-
-  end
-
-  def teardown
-    NewRelic::Agent.config.remove_config(@test_config)
-  end
-
-  def test_be_recorded
-    refute_nil @t
-  end
-
-  def test_prepare_to_send_strips_sql_if_record_sql_is_off_or_none_or_false
-    record_sql_values = %w(off none false)
-    record_sql_values.each do |record_sql_value|
-      s = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
-      with_config(:'transaction_tracer.record_sql' => record_sql_value) do
-        s.prepare_to_send!
-        s.each_segment do |segment|
-          assert_nil segment.params[:explain_plan]
-          assert_nil segment.params[:sql]
-        end
-      end
-    end
-  end
-
-  def test_prepare_to_send_preserves_raw_sql_if_record_sql_set_to_raw
-    with_config(:'transaction_tracer.record_sql' => 'raw') do
-      @t.prepare_to_send!
-    end
-
-    sql_statements = extract_captured_sql(@t)
-    assert_equal([::SQL_STATEMENT], sql_statements)
-  end
-
-  def test_prepare_to_send_obfuscates_sql_if_record_sql_set_to_obfuscated
-    with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
-      @t.prepare_to_send!
-    end
-
-    sql_statements = extract_captured_sql(@t)
-    assert_equal([::OBFUSCATED_SQL_STATEMENT], sql_statements)
-  end
-
-  def test_have_sql_rows_when_sql_is_recorded
-    with_config(:'transaction_tracer.record_sql' => 'off') do
-      @t.prepare_to_send!
-    end
-
-    assert @t.sql_segments.empty?
-    @t.root_segment[:sql] = 'hello'
-    assert !@t.sql_segments.empty?
-  end
-
-  def test_have_sql_rows_when_sql_is_obfuscated
-    with_config(:'transaction_tracer.record_sql' => 'off') do
-      @t.prepare_to_send!
-    end
-
-    assert @t.sql_segments.empty?
-    @t.root_segment[:sql_obfuscated] = 'hello'
-    assert !@t.sql_segments.empty?
-  end
-
-  def test_have_sql_rows_when_recording_non_sql_keys
-    with_config(:'transaction_tracer.record_sql' => 'off') do
-      @t.prepare_to_send!
-    end
-
-    assert @t.sql_segments.empty?
-    @t.root_segment[:key] = 'hello'
-    assert !@t.sql_segments.empty?
-  end
-
-  def test_catch_exceptions
-    config = {
-      :'transaction_tracer.record_sql'        => 'obfuscated',
-      :'transaction_tracer.explain_enabled'   => true,
-      :'transaction_tracer.explain_threshold' => 0.00000001
-    }
-
-    @connection_stub.expects(:execute).raises
-    with_config(config) do
-      @t.prepare_to_send!
-    end
-  end
-
-  def test_have_explains
-    config = {
-      :'transaction_tracer.record_sql'        => 'obfuscated',
-      :'transaction_tracer.explain_enabled'   => true,
-      :'transaction_tracer.explain_threshold' => 0.00000001
-    }
-
-    with_config(config) do
-      @t.prepare_to_send!
-    end
-
-    @t.each_segment do |segment|
-      if segment.params[:explain_plan]
-        explanation = segment.params[:explain_plan]
-
-        assert_kind_of Array, explanation
-        assert_equal([['foo'], [['bar']]], explanation)
-      end
-    end
-  end
-
-  def test_not_record_transactions
-    NewRelic::Agent.instance.transaction_sampler.reset!
-
-    NewRelic::Agent.disable_transaction_tracing do
-      t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
-      assert t.nil?
-    end
-  end
-
-  def test_path_string
-    s = @t.prepare_to_send!
-    fake_segment = mock('segment')
-    fake_segment.expects(:path_string).returns('a path string')
-    s.instance_eval do
-      @root_segment = fake_segment
-    end
-
-    assert_equal('a path string', s.path_string)
-  end
-
-  def test_params_equals
-    s = @t.prepare_to_send!
-    s.params = {:params => 'hash' }
-    assert_equal({:params => 'hash'}, s.params, "should have the specified hash, but instead was #{s.params}")
-  end
-
-  class Hat
-    # just here to mess with the to_s logic in transaction samples
-  end
-
-  def test_to_s_with_bad_object
-    @t.prepare_to_send!
-    @t.params[:fake] = Hat.new
-    assert_raises(RuntimeError) do
-      @t.to_s
-    end
-  end
-
-  def test_to_s_includes_keys
-    @t.prepare_to_send!
-    @t.params[:fake_key] = 'a fake param'
-    assert(@t.to_s.include?('fake_key'), "should include 'fake_key' but instead was (#{@t.to_s})")
-    assert(@t.to_s.include?('a fake param'), "should include 'a fake param' but instead was (#{@t.to_s})")
-  end
-
-  def test_find_segment
-    s = @t.prepare_to_send!
-    fake_segment = mock('segment')
-    fake_segment.expects(:find_segment).with(1).returns('a segment')
-    s.instance_eval do
-      @root_segment = fake_segment
-    end
-
-    assert_equal('a segment', s.find_segment(1))
-  end
-
-  def test_timestamp
-    s = @t.prepare_to_send!
-    assert(s.timestamp.instance_of?(Float), "s.timestamp should be a Float, but is #{s.timestamp.class.inspect}")
-  end
-
-  def test_xray_session_id
-    @t.xray_session_id = 123
-    s = @t.prepare_to_send!
-    assert_equal(123, s.xray_session_id)
-  end
-
-  def test_prepare_to_send_marks_returned_sample_as_prepared
-    assert(!@t.prepared?)
-    prepared_sample = @t.prepare_to_send!
-    assert(prepared_sample.prepared?)
-  end
-
-  def test_prepare_to_send_does_not_re_prepare
-    @t.prepare_to_send!
-    @t.expects(:collect_explain_plans!).never
-    @t.expects(:prepare_sql_for_transmission!).never
-    @t.prepare_to_send!
-  end
-
-  def test_threshold_preserved_by_prepare_to_send
-    @t.threshold = 4.2
-    s = @t.prepare_to_send!
-    assert_equal(4.2, s.threshold)
-  end
-
-  def test_count_segments
-    transaction = run_sample_trace do |sampler|
-      state = NewRelic::Agent::TransactionState.tl_get
-      sampler.notice_push_frame(state, "level0")
-      sampler.notice_push_frame(state, "level-1")
-      sampler.notice_push_frame(state, "level-2")
-      sampler.notice_sql(::SQL_STATEMENT, {}, 0, state)
-      sampler.notice_pop_frame(state, "level-2")
-      sampler.notice_pop_frame(state, "level-1")
-      sampler.notice_pop_frame(state, "level0")
-    end
-
-    assert_equal 6, transaction.count_segments
-  end
-
-  def test_to_array
-    # Round-trip through Time.at makes minor rounding diffs in Rubinius
-    # Check each element separately so we can reconcile the delta
-    result = @t.to_array
-    assert_equal 4, result.length
-
-    assert_in_delta(@t.start_time.to_f, result[0], 0.000001)
-    assert_equal @t.params[:request_params], result[1]
-    assert_equal @t.params[:custom_params], result[2]
-    assert_equal @t.root_segment.to_array, result[3]
-  end
-
-
-  def test_to_array_with_bad_values
-    transaction = NewRelic::TransactionSample.new(nil)
-    expected = [0.0, {}, nil, [0, 0, "ROOT", {}, []]]
-    assert_equal expected, transaction.to_array
-  end
-
-  def test_to_collector_array
-    expected_array = [(@t.start_time.to_f * 1000).round,
-                      (@t.duration * 1000).round,
-                      @t.params[:path], @t.params[:uri],
-                      trace_tree,
-                      @t.guid, nil, !!@t.force_persist,
-                      @t.xray_session_id,
-                      @t.synthetics_resource_id]
-
-    assert_collector_arrays_match expected_array, @t.to_collector_array(@marshaller.default_encoder)
-
-  end
-
-  def assert_collector_arrays_match(expected_array, actual_array)
-    expected_array[4] = expand_trace_tree(expected_array[4])
-    actual_array[4]   = expand_trace_tree(actual_array[4])
-
-    assert_equal expected_array, actual_array
-  end
-
-  def test_to_collector_array_forces_xrays
-    @t.force_persist = false
-    @t.xray_session_id = 123
-    result = @t.to_collector_array(@marshaller.default_encoder)
-    assert_equal true, result[FORCE_PERSIST_POSITION]
-  end
-
-  def test_to_collector_array_uses_synthetics_resource_id
-    @t.synthetics_resource_id = '42'
-    result = @t.to_collector_array(@marshaller.default_encoder)
-    assert_equal '42', result[SYNTHETICS_POSITION]
-  end
-
-  def test_to_collector_array_with_bad_values
-    transaction = NewRelic::TransactionSample.new(nil)
-    transaction.root_segment.end_trace(Rational(10, 1))
-    transaction.xray_session_id = "booooooo"
-
-    expected = [
-      0, 10_000,
-      nil, nil,
-      trace_tree(transaction),
-      transaction.guid,
-      nil, false, nil, nil]
-
-    actual = transaction.to_collector_array(@marshaller.default_encoder)
-    assert_collector_arrays_match expected, actual
-  end
-
-  INVALID_UTF8_STRING = (''.respond_to?(:force_encoding) ? "\x80".force_encoding('UTF-8') : "\x80")
-
-  def test_prepare_to_send_with_incorrectly_encoded_string_in_sql_query
-    query = "SELECT * FROM table WHERE col1=\"#{INVALID_UTF8_STRING}\" AND col2=\"whatev\""
-
-    t = nil
-    with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
-      t = make_sql_transaction(query)
-      t.prepare_to_send!
-    end
-
-    sql_statements = extract_captured_sql(t)
-    assert_equal(["SELECT * FROM table WHERE col1=? AND col2=?"], sql_statements)
-  end
-
-  def test_multiple_calls_to_notice_sequel_appends_sql
-    queries = ["BEGIN", "INSERT items(title) VALUES('title')", "COMMIT"]
-
-    t = make_sql_transaction(*queries)
-    sql_statements = extract_captured_sql(t)
-
-    assert_equal [queries.join("\n")], sql_statements
-  end
-
-  def trace_tree(transaction=@t)
-    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
-      trace_tree = compress(JSON.dump(transaction.to_array))
-    else
-      trace_tree = transaction.to_array
-    end
-  end
-
-  def compress(string)
-    Base64.encode64(Zlib::Deflate.deflate(string, Zlib::DEFAULT_COMPRESSION))
-  end
-
-  def expand_trace_tree(encoded_tree)
-    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
-      JSON.load(Zlib::Inflate.inflate(Base64.decode64(encoded_tree)))
-    else
-      encoded_tree
-    end
-  end
-
-  def extract_captured_sql(trace)
-    sqls = []
-    trace.each_segment do |s|
-      sqls << s.params[:sql]
-    end
-    sqls.compact
-  end
-end