newrelic_rpm 3.6.2.96 → 3.6.3.103.beta

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -465,7 +465,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     with_config(:'transaction_tracer.limit_segments' => 2000) do
       sample = mock('sample')
       @sampler.expects(:add_samples_to).with([sample]).returns([sample])
-      sample.expects(:truncate).with(2000)
       assert_equal([sample], @sampler.harvest([sample]))
     end
   end
@@ -935,6 +934,26 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert_equal '97612F92E6194080', @sampler.builder.current_segment[:transaction_guid]
   end
 
+  def test_large_transaction_trace_harvest
+    config = {
+      :'transaction_tracer.enabled' => true,
+      :'transaction_tracer.transaction_threshold' => 0,
+      :'transaction_tracer.limit_segments' => 100
+    }
+    with_config(config) do
+      run_long_sample_trace(110)
+
+      samples = nil
+      assert_nothing_raised do
+        samples = @sampler.harvest
+      end
+      assert_equal(1, samples.size)
+
+      # Verify that the TT stopped recording after 100 nodes
+      assert_equal(100, samples.first.count_segments)
+    end
+  end
+
   class Dummy
     include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
     def run(n)
@@ -959,6 +978,17 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
   private
 
+  def run_long_sample_trace(n)
+    @sampler.notice_transaction(nil, {})
+    @sampler.notice_first_scope_push(Time.now.to_f)
+    n.times do |i|
+      @sampler.notice_push_scope
+      yield if block_given?
+      @sampler.notice_pop_scope "node#{i}"
+    end
+    @sampler.notice_scope_empty(@txn, Time.now.to_f)
+  end
+
   def run_sample_trace(start = Time.now.to_f, stop = nil)
     @sampler.notice_transaction(nil, {})
     @sampler.notice_first_scope_push start

data/test/new_relic/agent/transaction_test.rb

@@ -186,4 +186,33 @@ class NewRelic::Agent::TransactionTest < Test::Unit::TestCase
     NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
                                               NewRelic::Agent::RulesEngine.new)
   end
+
+  def test_end_fires_a_transaction_finished_event
+    name, duration = nil
+    NewRelic::Agent.subscribe(:transaction_finished) do |*args|
+      name     = args.shift
+      duration = args.shift
+    end
+
+    NewRelic::Agent::Transaction.start(:controller)
+    NewRelic::Agent.set_transaction_name('foo/1/bar/22')
+    NewRelic::Agent::Transaction.freeze_name
+    NewRelic::Agent::Transaction.stop('txn')
+
+    assert_equal 'Controller/foo/1/bar/22', name
+    assert_kind_of Float, duration
+  end
+
+  def test_end_fires_a_transaction_finished_event_with_overview_metrics
+    options = nil
+    NewRelic::Agent.subscribe(:transaction_finished) do |_, _, opts|
+      options = opts
+    end
+
+    NewRelic::Agent::Transaction.start(:controller)
+    NewRelic::Agent.record_metric("HttpDispatcher", 2.1)
+    NewRelic::Agent::Transaction.stop('txn')
+
+    assert_equal 2.1, options[:web_duration]
+  end
 end

data/test/new_relic/agent_test.rb

@@ -380,6 +380,13 @@ module NewRelic
       end
     end
 
+    def test_eventing_helpers
+      called = false
+      NewRelic::Agent.subscribe(:boo) { called = true }
+      NewRelic::Agent.notify(:boo)
+      assert called
+    end
+
     private
 
     def mocked_agent

data/test/new_relic/coerce_test.rb

@@ -47,6 +47,19 @@ class CoerceTest < Test::Unit::TestCase
     float("not valid", "HERE")
   end
 
+  def test_float_coerce_with_infinite_value_logs_and_returns_0_0
+    expects_logging(:warn, all_of(includes("TestingInfinity"), includes("Float"), includes("'Infinity'")), anything)
+    infinity = 1337807.0/0.0
+    result = float(infinity, "TestingInfinity")
+    assert_equal 0.0, result
+  end
+
+  def test_float_coerce_with_nan_value_logs_and_returns_0_0
+    expects_logging(:warn, all_of(includes("TestingNaN"), includes("Float"), includes("'NaN'")), anything)
+    nan = 0.0/0.0
+    result = float(nan, "TestingNaN")
+    assert_equal 0.0, result
+  end
 
   def test_string_coerce
     assert_equal "1",      string(1)

data/test/new_relic/fake_collector.rb

@@ -25,7 +25,8 @@ module NewRelic
         'sql_trace_data'          => [200, {'return_value' => nil}],
         'transaction_sample_data' => [200, {'return_value' => nil}],
         'error_data'              => [200, {'return_value' => nil}],
-        'shutdown'                => [200, {'return_value' => nil}]
+        'shutdown'                => [200, {'return_value' => nil}],
+        'analytic_event_data'     => [200, {'return_value' => nil}]
       }
       reset
     end
@@ -195,6 +196,8 @@ module NewRelic
           SqlTraceDataPost.new(opts)
         when 'transaction_sample_data'
           TransactionSampleDataPost.new(opts)
+        when 'analytic_event_data'
+          AnalyticEventDataPost.new(opts)
         else
           new(opts)
         end
@@ -244,6 +247,15 @@ module NewRelic
         @body[1][0][2]
       end
     end
+    class AnalyticEventDataPost < AgentPost
+
+      def initialize(opts={})
+        opts[:run_id] = opts[:body].shift
+        opts[:body] = opts[:body].shift
+
+        super
+      end
+    end
   end
 
   # might we need this?  I'll just leave it here for now
@@ -346,6 +358,24 @@ if $0 == __FILE__
       assert_equal ['error'], post.body
     end
 
+    def test_analytic_event_data
+      events = [
+        {
+          'type' => 'Transaction',
+          'name' => 'Controller/foo/bar',
+          'duration' => '718',
+          'timestamp' => 1368489547.888435
+        }
+      ]
+      response = invoke('analytic_event_data', [33, events])
+
+      assert_nil response['return_value']
+      post = @collector.agent_data[0]
+      assert_equal 'analytic_event_data', post.action
+      assert_equal events, post.body
+      assert_equal 33, post.run_id.to_i
+    end
+
     def test_shutdown
       response = invoke('shutdown?run_id=1')
 

data/test/new_relic/metric_spec_test.rb

@@ -43,24 +43,28 @@ class NewRelic::MetricSpecTest < Test::Unit::TestCase
   end
 
   # test to make sure the MetricSpec class can serialize to json
-  def test_json
-    spec = NewRelic::MetricSpec.new("controller", "metric#find")
+  if defined?(::ActiveSupport)
+    def test_json
+      spec = NewRelic::MetricSpec.new("controller", "metric#find")
 
-    import = ::ActiveSupport::JSON.decode(spec.to_json)
+      import = ::ActiveSupport::JSON.decode(spec.to_json)
 
-    compare_spec(spec, import)
+      compare_spec(spec, import)
 
-    stats = NewRelic::Agent::Stats.new
+      stats = NewRelic::Agent::Stats.new
 
-    import = ::ActiveSupport::JSON.decode(stats.to_json)
+      import = ::ActiveSupport::JSON.decode(stats.to_json)
 
-    compare_stat(stats, import)
+      compare_stat(stats, import)
 
-    metric_data = NewRelic::MetricData.new(spec, stats, 10)
+      metric_data = NewRelic::MetricData.new(spec, stats, 10)
 
-    import = ::ActiveSupport::JSON.decode(metric_data.to_json)
+      import = ::ActiveSupport::JSON.decode(metric_data.to_json)
 
-    compare_metric_data(metric_data, import)
+      compare_metric_data(metric_data, import)
+    end
+  else
+    puts "Skipping tests in #{__FILE__} because ActiveSupport is unavailable"
   end
 
   def test_truncate!

data/test/new_relic/rack/agent_hooks_test.rb

@@ -11,12 +11,11 @@ class AgentHooksTest < Test::Unit::TestCase
     @app = stub_everything
     @hooks = NewRelic::Rack::AgentHooks.new(@app)
     @env = {:env => "env"}
-
-    NewRelic::Agent.instance.events.stubs(:notify)
   end
 
   def test_before_call
     NewRelic::Agent.instance.events.expects(:notify).with(:before_call, @env)
+    NewRelic::Agent.instance.events.stubs(:notify).with(:after_call, anything, anything)
 
     @hooks.call(@env)
   end
@@ -25,10 +24,18 @@ class AgentHooksTest < Test::Unit::TestCase
     result = stub
     @app.stubs(:call).returns(result)
 
+    NewRelic::Agent.instance.events.stubs(:notify).with(:before_call, anything)
     NewRelic::Agent.instance.events.expects(:notify).with(:after_call, @env, result)
 
     @hooks.call(@env)
   end
 
+  def test_nested_agent_hooks_still_fire_only_once
+    nested = NewRelic::Rack::AgentHooks.new(@hooks)
+
+    NewRelic::Agent.instance.events.expects(:notify).times(2)
+    nested.call(@env)
+  end
+
 end
 

data/test/new_relic/rack/browser_monitoring_test.rb

@@ -14,7 +14,7 @@ ENV['RACK_ENV'] = 'test'
 # benefit from auto-rum, but the truth of the matter is that atm
 # we only support Rails >= 2.3
 def middleware_supported?
-  ::Rails::VERSION::STRING >= '2.3'
+  defined?(::Rails) && ::Rails::VERSION::STRING >= '2.3'
 end
 
 if middleware_supported?
@@ -83,13 +83,17 @@ EOL
   end
 
   def test_should_only_instrument_successfull_html_requests
-    assert app.should_instrument?(200, {'Content-Type' => 'text/html'})
-    assert !app.should_instrument?(500, {'Content-Type' => 'text/html'})
-    assert !app.should_instrument?(200, {'Content-Type' => 'text/xhtml'})
+    assert app.should_instrument?({}, 200, {'Content-Type' => 'text/html'})
+    assert !app.should_instrument?({}, 500, {'Content-Type' => 'text/html'})
+    assert !app.should_instrument?({}, 200, {'Content-Type' => 'text/xhtml'})
   end
 
   def test_should_not_instrument_when_content_disposition
-    assert !app.should_instrument?(200, {'Content-Type' => 'text/html', 'Content-Disposition' => 'attachment; filename=test.html'})
+    assert !app.should_instrument?({}, 200, {'Content-Type' => 'text/html', 'Content-Disposition' => 'attachment; filename=test.html'})
+  end
+
+  def test_should_not_instrument_when_already_did
+    assert !app.should_instrument?({NewRelic::Rack::BrowserMonitoring::ALREADY_INSTRUMENTED_KEY => true}, 200, {'Content-Type' => 'text/html'})
   end
 
   def test_insert_timing_header_right_after_open_head_if_no_meta_tags
@@ -100,6 +104,12 @@ EOL
     TestApp.doc = nil
   end
 
+  def test_insert_header_should_mark_environment
+    get '/'
+    assert last_request.env.key?(NewRelic::Rack::BrowserMonitoring::ALREADY_INSTRUMENTED_KEY)
+    TestApp.doc = nil
+  end
+
   def test_insert_timing_header_right_before_head_close_if_ua_compatible_found
     TestApp.doc = <<-EOL
 <html>
@@ -152,6 +162,5 @@ EOL
   end
 end
 else
-  warn "Skipping rum auto instrumentation tests"
+  puts "Skipping tests in #{__FILE__} because Rails is unavailable (or too old)"
 end
-

data/test/new_relic/rack/developer_mode_test.rb

@@ -3,6 +3,9 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 # ENV['SKIP_RAILS'] = 'true'
+
+if defined?(::Rails)
+
 require File.expand_path(File.join(File.dirname(__FILE__),'..', '..',
                                    'test_helper'))
 require 'rack/test'
@@ -82,3 +85,7 @@ class DeveloperModeTest < Test::Unit::TestCase
     }]
   end
 end
+
+else
+  puts "Skipping tests in #{__FILE__} because Rails is unavailable"
+end

data/test/new_relic/rack/error_collector_test.rb

@@ -62,13 +62,17 @@ module NewRelic::Rack
              'noticed an error that should have been ignored')
     end
 
-    def test_ignore_errors_from_ignored_actions
-      assert_raise RuntimeError do
-        get '/ignored'
-      end
+    if defined?(::Rails)
+      def test_ignore_errors_from_ignored_actions
+        assert_raise RuntimeError do
+          get '/ignored'
+        end
 
-      assert(NewRelic::Agent.instance.error_collector.errors.empty?,
-             'noticed an error that should have been ignored')
+        assert(NewRelic::Agent.instance.error_collector.errors.empty?,
+               'noticed an error that should have been ignored')
+      end
+    else
+      puts "Skipping tests in #{__FILE__} because Rails is unavailable"
     end
 
     def test_handles_parameter_parsing_exceptions

data/test/new_relic/transaction_sample/segment_test.rb

@@ -220,67 +220,6 @@ class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
     s.add_called_segment(fake_segment)
 
     assert_equal(2, s.count_segments)
-    end
-
-  def test_truncate_returns_number_of_elements
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-    assert_equal(1, s.truncate(1))
-    dup = s.dup
-    s.called_segments = [dup]
-    assert_equal(2, s.truncate(2))
-
-    s.called_segments = [dup, dup]
-    assert_equal(3, s.truncate(3))
-  end
-
-
-  def test_truncate_default
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-
-    assert_equal(1, s.truncate(1))
-  end
-
-  def test_truncate_with_a_child
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-
-    fake_segment = mock('segment')
-    fake_segment.expects(:parent_segment=).with(s)
-    fake_segment.expects(:truncate).with(1).returns(1)
-
-    s.add_called_segment(fake_segment)
-
-    assert_equal(2, s.truncate(2))
-    assert_equal([fake_segment], s.called_segments)
-
-    assert_equal(1, s.truncate(1))
-    assert_equal([], s.called_segments)
-  end
-
-  def test_truncate_with_multiple_children
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-
-    fake_segment = mock('segment')
-    fake_segment.expects(:truncate).with(2).returns(1)
-
-    other_segment = mock('other segment')
-    other_segment.expects(:truncate).with(1).returns(1)
-
-    s.called_segments = [fake_segment, other_segment]
-    assert_equal(3, s.truncate(3))
-    assert_equal([fake_segment, other_segment], s.called_segments)
-  end
-
-  def test_truncate_removes_elements
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-
-    fake_segment = mock('segment')
-    fake_segment.expects(:truncate).with(1).returns(1)
-
-    other_segment = mock('other segment')
-
-    s.called_segments = [fake_segment, other_segment]
-    assert_equal(2, s.truncate(2))
-    assert_equal([fake_segment], s.called_segments)
   end
 
   def test_key_equals

data/test/new_relic/transaction_sample_subtest_test.rb

@@ -38,23 +38,4 @@ class NewRelic::TransactionSample::SubTest < Test::Unit::TestCase
   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/script/ci.sh

@@ -78,6 +78,20 @@ mkdir -p tmp
 cd tmp
 
 
+if [ "x$BRANCH" == "xnorails" ]; then
+  if [ "x$RUBY_VERSION" == "x1.8.6" ]; then
+    # Bundler 1.1 dropped support for ruby 1.8.6
+    bundle -h > /dev/null || gem install bundler -v'~>1.0.0' --no-rdoc --no-ri
+  else
+    bundle -h > /dev/null || gem install bundler --no-rdoc --no-ri
+  fi
+
+  bundle -v
+  bundle --local || bundle
+  NO_RAILS=true bundle exec rake --trace test || bundle exec rake --trace test
+  exit
+fi
+
 #rpm_test_app_cache=~/.rpm_test_app_cache
 rpm_test_app_cache=~/workspace/.rpm_test_app_cache
 (