sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/transaction_sample/summary_segment_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/transaction_sample/summary_segment'
+class NewRelic::TransactionSample::SummarySegmentTest < Test::Unit::TestCase
+  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

@@ -0,0 +1,56 @@
+class NewRelic::TransactionSample::SubTest < Test::Unit::TestCase
+  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
+
+  def test_truncate_long_samples
+    @t.truncate(2)
+    assert_equal 2, @t.count_segments
+
+    @t = NewRelic::TransactionSample.new
+
+    s1 = @t.create_segment(1.0, "controller")
+    @t.root_segment.add_called_segment(s1)
+
+    100.times do
+      s1.add_called_segment(@t.create_segment(1.0, "segment"))
+    end
+    assert_equal 101, @t.count_segments
+    @t.truncate(2)
+    assert_equal 2, @t.count_segments
+    assert_equal 101, @t.params[:segment_count]
+  end
+
+end

data/test/new_relic/transaction_sample_test.rb

@@ -0,0 +1,250 @@
+require File.expand_path('../../test_helper.rb', __FILE__)
+
+class NewRelic::TransactionSampleTest < Test::Unit::TestCase
+  include TransactionSampleTestHelper
+  ::SQL_STATEMENT = "SELECT * from sandwiches"
+
+  def setup
+    @test_config = { :developer_mode => true }
+    NewRelic::Agent.config.apply_config(@test_config)
+    @connection_stub = Mocha::Mockery.instance.named_mock('connection')
+    @connection_stub.stubs(:execute).returns([['QUERY RESULT']])
+
+    NewRelic::Agent::Database.stubs(:get_connection).returns @connection_stub
+    @t = make_sql_transaction(::SQL_STATEMENT, ::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
+    assert_not_nil @t
+  end
+
+  def test_not_record_sql_when_record_sql_off
+    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+    s.each_segment do |segment|
+      assert_nil segment.params[:explain_plan]
+      assert_nil segment.params[:sql]
+    end
+  end
+
+  def test_record_raw_sql
+    s = @t.prepare_to_send(:explain_sql => 0.00000001, :record_sql => :raw)
+    got_one = false
+    s.each_segment do |segment|
+      fail if segment.params[:obfuscated_sql]
+      got_one = got_one || segment.params[:explain_plan] || segment.params[:sql]
+    end
+    assert got_one
+  end
+
+  def test_record_obfuscated_sql
+
+    s = @t.prepare_to_send(:explain_sql => 0.00000001, :record_sql => :obfuscated)
+
+    got_one = false
+    s.each_segment do |segment|
+      got_one = got_one || segment.params[:explain_plan] || segment.params[:sql]
+    end
+
+    assert got_one
+  end
+
+  def test_have_sql_rows_when_sql_is_recorded
+    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+
+    assert s.sql_segments.empty?
+    s.root_segment[:sql] = 'hello'
+    assert !s.sql_segments.empty?
+  end
+
+  def test_have_sql_rows_when_sql_is_obfuscated
+    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+
+    assert s.sql_segments.empty?
+    s.root_segment[:sql_obfuscated] = 'hello'
+    assert !s.sql_segments.empty?
+  end
+
+  def test_have_sql_rows_when_recording_non_sql_keys
+    s = @t.prepare_to_send(:explain_sql => 0.00000001)
+
+    assert s.sql_segments.empty?
+    s.root_segment[:key] = 'hello'
+    assert !s.sql_segments.empty?
+  end
+
+  def test_catch_exceptions
+    @connection_stub.expects(:execute).raises
+    # the sql connection will throw
+    @t.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.00000001)
+  end
+
+  def test_have_explains
+    s = @t.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.00000001)
+
+    s.each_segment do |segment|
+      if segment.params[:explain_plan]
+        explanation = segment.params[:explain_plan]
+
+        assert_kind_of Array, explanation
+        assert_equal([nil, [["QUERY RESULT"]]], explanation)
+      end
+    end
+  end
+
+  def test_not_record_sql_without_record_sql_option
+    t = nil
+    NewRelic::Agent.disable_sql_recording do
+      t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    end
+
+    s = t.prepare_to_send(:explain_sql => 0.00000001)
+
+    s.each_segment do |segment|
+      assert_nil segment.params[:explain_plan]
+      assert_nil segment.params[:sql]
+    end
+  end
+
+  def test_not_record_transactions
+    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(:explain_sql => 0.1)
+    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(:explain_sql => 0.1)
+    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
+    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s.params[:fake] = Hat.new
+    assert_raise(RuntimeError) do
+      s.to_s
+    end
+  end
+
+  def test_to_s_includes_keys
+    s = @t.prepare_to_send(:explain_sql => 0.1)
+    s.params[:fake_key] = 'a fake param'
+    assert(s.to_s.include?('fake_key'), "should include 'fake_key' but instead was (#{s.to_s})")
+    assert(s.to_s.include?('a fake param'), "should include 'a fake param' but instead was (#{s.to_s})")
+  end
+
+  def test_find_segment
+    s = @t.prepare_to_send(:explain_sql => 0.1)
+    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(:explain_sql => 0.1)
+    assert(s.timestamp.instance_of?(Float), "s.timestamp should be a Float, but is #{s.timestamp.class.inspect}")
+  end
+
+  def test_count_segments
+    transaction = run_sample_trace_on(NewRelic::Agent::TransactionSampler.new) do |sampler|
+      sampler.notice_push_scope "level0"
+      sampler.notice_push_scope "level-1"
+      sampler.notice_push_scope "level-2"
+      sampler.notice_sql(::SQL_STATEMENT, nil, 0)
+      sampler.notice_pop_scope "level-2"
+      sampler.notice_pop_scope "level-1"
+      sampler.notice_pop_scope "level0"
+    end
+    assert_equal 6, transaction.count_segments
+  end
+
+  def test_to_array
+    expected_array = [@t.start_time.to_f,
+                      @t.params[:request_params],
+                      @t.params[:custom_params],
+                      @t.root_segment.to_array]
+    assert_equal expected_array, @t.to_array
+  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
+
+  if RUBY_VERSION >= '1.9.2'
+    def test_to_json
+      expected_string = JSON.dump([@t.start_time.to_f,
+                                   @t.params[:request_params],
+                                   @t.params[:custom_params],
+                                   @t.root_segment.to_array])
+      assert_equal expected_string, @t.to_json
+    end
+  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]
+
+    assert_equal expected_array, @t.to_collector_array(@marshaller.default_encoder)
+  end
+
+  def test_to_collector_array_with_bad_values
+    transaction = NewRelic::TransactionSample.new(nil)
+    transaction.root_segment.end_trace(Rational(10, 1))
+
+    expected = [
+      0, 10_000,
+      nil, nil,
+      trace_tree(transaction),
+      transaction.guid,
+      nil, false]
+
+    assert_equal expected, transaction.to_collector_array(@marshaller.default_encoder)
+  end
+
+  def trace_tree(transaction=@t)
+    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+      trace_tree = compress(transaction.to_json)
+    else
+      trace_tree = transaction.to_array
+    end
+  end
+
+  def compress(string)
+    Base64.encode64(Zlib::Deflate.deflate(string, Zlib::DEFAULT_COMPRESSION))
+  end
+end

data/test/new_relic/version_number_test.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+class NewRelic::VersionNumberTest < Test::Unit::TestCase
+
+  def test_comparison__first
+    versions = %w[1.0.0 0.1.0 0.0.1 10.0.1 1.10.0].map {|s| NewRelic::VersionNumber.new s }
+    assert_equal %w[0.0.1 0.1.0 1.0.0 1.10.0 10.0.1], versions.sort.map(&:to_s)
+    v0 = NewRelic::VersionNumber.new '1.2.3'
+    v1 = NewRelic::VersionNumber.new '1.2.2'
+    v3 = NewRelic::VersionNumber.new '1.2.2'
+    assert v0 > v1
+    assert v1 == v1
+    assert v1 == v3
+  end
+  def test_comparison__second
+    v0 = NewRelic::VersionNumber.new '1.2.0'
+    v1 = NewRelic::VersionNumber.new '2.2.2'
+    v3 = NewRelic::VersionNumber.new '1.1.2'
+    assert v0 < v1
+    assert v1 > v3
+    assert v3 < v0
+  end
+  def test_bug
+    v0 = NewRelic::VersionNumber.new '2.8.999'
+    v1 = NewRelic::VersionNumber.new '2.9.10'
+    assert v1 > v0
+    assert v0 <= v1
+  end
+  def test_long_version
+    v0 = NewRelic::VersionNumber.new '1.2.3.4'
+    v1 = NewRelic::VersionNumber.new '1.2.3.3'
+    v3 = NewRelic::VersionNumber.new '1.3'
+    assert v0 > v1
+    assert v0 < '1.2.3.5'
+    assert ! (v0 < '1.2.3.4')
+    assert v3 > v0
+  end
+  def test_sort
+    values = %w[1.1.1
+                1.1.99
+                1.1.999
+                2.0.6
+                2.6.5
+                2.7
+                2.7.1
+                2.7.2
+                2.7.2.0
+                3
+                999]
+    assert_equal values, values.map{|v| NewRelic::VersionNumber.new v}.sort.map(&:to_s)
+  end
+  def test_prerelease
+    v0 = NewRelic::VersionNumber.new '1.2.0.beta'
+    assert_equal [1,2,0,'beta'], v0.parts
+    assert v0 > '1.1.9.0'
+    assert v0 > '1.1.9.alpha'
+    assert v0 > '1.2.0.alpha'
+    assert v0 == '1.2.0.beta'
+    assert v0 < '1.2.1'
+    assert v0 < '1.2.0'
+    assert v0 < '1.2.0.c'
+    assert v0 < '1.2.0.0'
+
+  end
+  def test_compare_string
+    v0 = NewRelic::VersionNumber.new '1.2.0'
+    v1 = NewRelic::VersionNumber.new '2.2.2'
+    v3 = NewRelic::VersionNumber.new '1.1.2'
+    assert v0 < '2.2.2'
+    assert v1 > '1.1.2'
+    assert v3 < '1.2.0'
+    assert v0 == '1.2.0'
+  end
+  def test_4_numbers
+    v0 = NewRelic::VersionNumber.new '1.2.0'
+    v1 = NewRelic::VersionNumber.new '1.2.0.1'
+    v2 = NewRelic::VersionNumber.new '1.2.1.0'
+    v3 = NewRelic::VersionNumber.new '1.2.1.1'
+    assert v0 < v1
+    assert v1 < v2
+    assert v2 < v3
+    assert v0 < v3
+    assert v0 < '1.2.0.1'
+    assert v0 > '1.1.0.1'
+  end
+
+  def test_string
+    assert_equal '1.2.0', NewRelic::VersionNumber.new('1.2.0').to_s
+    assert_equal '1.2', NewRelic::VersionNumber.new('1.2').to_s
+  end
+
+  def test_build_version_string
+    version_string = NewRelic::VERSION.build_version_string(1, 2, 3, '4.beta')
+    assert_equal('1.2.3.4.beta', version_string)
+    version_string = NewRelic::VERSION.build_version_string(1, 2, 3, nil)
+    assert_equal('1.2.3', version_string)
+  end
+end

data/test/script/build_test_gem.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+# print commands in this script as they're invoked
+#set -x
+# fail if any command fails
+set -e
+
+. "$HOME/.rvm/scripts/rvm"
+
+#rvm 1.9.3
+
+
+if [ "x$BUILD_NUMBER" == "x" ]; then
+  echo '$BUILD_NUMBER is undefined'
+  echo 'setting $BUILD_NUMBER to alpha'
+  BUILD_NUMBER=alpha
+fi
+
+SHA1=`git log --pretty=format:'%h' -n 1`
+echo "building gem for commit $SHA1"
+
+if [[ `gem list jeweler | grep [j]eweler | wc -l` -eq 1 ]]; then
+  echo "detected jeweler. skipping install"
+else
+  gem install jeweler --no-ri --no-rdoc
+fi
+
+# setup a gems directory as a work area for artifacts
+rm -rf gems/
+mkdir gems
+
+# an identifier including the hudson build number and the git sha1
+
+# FIXME: don't include the $SHA1 since some of our builds systems are confused
+# by this.
+#BUILD_ID="$SHA1.$BUILD_NUMBER" #.$SHA1
+BUILD_ID="$BUILD_NUMBER" #.$SHA1
+
+# rewrite the version file, setting the patch identifier to include the
+# BUILD_ID
+perl -p -i -e "s#BUILD *= *.*\$#BUILD = '$BUILD_ID'#" lib/new_relic/version.rb
+
+# generate the gemspec
+rake gemspec
+
+# build the gem
+gem build *.gemspec
+
+# move artifacts to the gems directory
+cp *.gemspec gems/
+mv *.gem gems/
+
+cd gems
+
+# create a tarfile including the gem and the gemspec
+gem_version=`ls *.gem | sed 's/\.gem$//' | sed 's/newrelic_rpm-//'`
+tar czvf newrelic_rpm_agent-${gem_version}.tar.gz *