newrelic_rpm 3.6.2.96 → 3.6.3.103.beta

data/test/new_relic/agent/instrumentation/sinatra/transaction_namer_test.rb

@@ -0,0 +1,55 @@
+# 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/agent/instrumentation/sinatra/transaction_namer'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Sinatra
+
+        class TransactionNamerTest < Test::Unit::TestCase
+
+          def test_transaction_name_for_route
+            env = { "newrelic.last_route" => /^\/the_route$/}
+            request = stub(:request_method => "GET")
+            result = TransactionNamer.transaction_name_for_route(env, request)
+            assert_equal "GET the_route", result
+          end
+
+          def test_transaction_name_for_route_padrino
+            env = {}
+            route = stub(:original_path => "/path/:id")
+            request = stub(:route_obj => route, :request_method => "GET")
+            result = TransactionNamer.transaction_name_for_route(env, request)
+
+            assert_equal "GET path/:id", result
+          end
+
+          def test_transaction_name_for_route_without_routes
+            assert_nil TransactionNamer.transaction_name_for_route({}, nil)
+          end
+
+          def test_basic_sinatra_naming
+            assert_transaction_name "(unknown)", "(unknown)"
+
+            # Sinatra < 1.4 style regexes
+            assert_transaction_name "will_boom", "^/will_boom$"
+            assert_transaction_name "hello/([^/?#]+)", "^/hello/([^/?#]+)$"
+
+            # Sinatra 1.4 style regexs
+            assert_transaction_name "will_boom", "\A/will_boom\z"
+            assert_transaction_name "hello/([^/?#]+)", "\A/hello/([^/?#]+)\z"
+          end
+
+          def assert_transaction_name(expected, original)
+            assert_equal expected, TransactionNamer.transaction_name(original, nil)
+          end
+
+        end
+      end
+    end
+  end
+end

data/test/new_relic/agent/instrumentation/sinatra_test.rb

@@ -6,24 +6,73 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'te
 require 'new_relic/agent/instrumentation/sinatra'
 
 class NewRelic::Agent::Instrumentation::SinatraTest < Test::Unit::TestCase
+
+  # This fake app is not an actual Sinatra app to avoid having our unit tests
+  # take a dependency directly on it. If you need actual Sinatra classes, go
+  # write the test in the multiver suite.
   class SinatraTestApp
-    def initialize(response)
-      @response = response
-    end
+    include NewRelic::Agent::Instrumentation::Sinatra
 
-    def dispatch!
-      @response = response
+    attr_accessor :env, :request
+
+    def initialize
+      @env = {}
     end
+  end
 
-    include NewRelic::Agent::Instrumentation::Sinatra
-    alias dispatch_without_newrelic dispatch!
-    alias dispatch! dispatch_with_newrelic
+  def setup
+    @app = SinatraTestApp.new
   end
 
   def test_newrelic_request_headers
-    app = SinatraTestApp.new([200, {}, ["OK"]])
     expected_headers = {:fake => :header}
-    app.expects(:request).returns(mock('request', :env => expected_headers))
-    assert_equal app.send(:newrelic_request_headers), expected_headers
+    @app.request = mock('request', :env => expected_headers)
+
+    assert_equal @app.newrelic_request_headers, expected_headers
+  end
+
+  def test_process_route_with_bad_arguments
+    @app.stubs(:env).raises("Boo")
+    @app.expects(:process_route_without_newrelic).once
+    @app.process_route_with_newrelic
+  end
+
+  def test_route_eval_with_bad_params
+    @app.stubs(:env).raises("Boo")
+    @app.expects(:route_eval_without_newrelic).once
+    @app.route_eval_with_newrelic
+  end
+
+  def test_route_eval_without_last_route_doesnt_set_transaction_name
+    @app.stubs(:env).returns({})
+    @app.expects(:route_eval_without_newrelic).once
+    NewRelic::Agent.expects(:set_transaction_name).never
+    @app.route_eval_with_newrelic
+  end
+
+  def test_injects_middleware
+    SinatraTestApp.stubs(:middleware).returns([])
+
+    SinatraTestApp.expects(:build_without_newrelic).once
+    SinatraTestApp.expects(:use).at_least(3)
+
+    SinatraTestApp.build_with_newrelic(@app)
+  end
+
+  def test_doesnt_inject_already_existing_middleware
+    default_middlewares = SinatraTestApp.newrelic_middlewares
+    # mock up the return value of Sinatra's #middleware method, which returns an
+    # Array of Arrays.
+    middleware_info = default_middlewares.map { |m| [m] }
+    SinatraTestApp.stubs(:middleware).returns(middleware_info)
+
+    SinatraTestApp.expects(:build_without_newrelic).once
+    SinatraTestApp.expects(:use).never
+
+    SinatraTestApp.build_with_newrelic(@app)
+  end
+
+  def assert_transaction_name(expected, original)
+    assert_equal expected, NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name(original, nil)
   end
 end

data/test/new_relic/agent/method_tracer_test.rb

@@ -69,12 +69,11 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     @stats_engine.clear_stats
     @scope_listener = NewRelic::Agent::MockScopeListener.new
     @old_sampler = NewRelic::Agent.instance.transaction_sampler
-    @stats_engine.transaction_sampler = @scope_listener
+    NewRelic::Agent.instance.stubs(:transaction_sampler).returns(@scope_listener)
     super
   end
 
   def teardown
-    @stats_engine.transaction_sampler = @old_sampler
     @stats_engine.clear_stats
     begin
       self.class.remove_method_tracer :method_to_be_traced, @metric_name if @metric_name
@@ -196,15 +195,19 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   def test_nested_scope_tracer
     Insider.add_method_tracer :catcher, "catcher", :push_scope => true
     Insider.add_method_tracer :thrower, "thrower", :push_scope => true
-    sampler = NewRelic::Agent.instance.transaction_sampler
+
+    # This expects to use the real transaction sampler, so stub it back
+    NewRelic::Agent.instance.stubs(:transaction_sampler).returns(@old_sampler)
+
     mock = Insider.new(@stats_engine)
     mock.catcher(0)
     mock.catcher(5)
+
     stats = @stats_engine.get_stats("catcher")
     assert_equal 2, stats.call_count
     stats = @stats_engine.get_stats("thrower")
     assert_equal 6, stats.call_count
-    sample = sampler.harvest
+    sample = @old_sampler.harvest
     assert_not_nil sample
   end
 

data/test/new_relic/agent/new_relic_service_test.rb

@@ -259,6 +259,12 @@ class NewRelicServiceTest < Test::Unit::TestCase
     assert_equal 'explain this', response
   end
 
+  def test_analytic_event_data
+    @http_handle.respond_to(:analytic_event_data, 'some analytic events')
+    response = @service.analytic_event_data([])
+    assert_equal 'some analytic events', response
+  end
+
 
 # Thread profiling only available in certain versions
 if NewRelic::Agent::ThreadProfiler.is_supported?

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -103,9 +103,13 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       assert_equal(2, NewRelic::Agent.agent.error_collector.errors.size)
     end
 
+    def pipe_finished?(id)
+      (!NewRelic::Agent::PipeChannelManager.channels[id] ||
+        NewRelic::Agent::PipeChannelManager.channels[id].closed?)
+    end
+
     def assert_pipe_finished(id)
-      assert(!NewRelic::Agent::PipeChannelManager.channels[id] ||
-        NewRelic::Agent::PipeChannelManager.channels[id].closed?,
+      assert(pipe_finished?(id),
         "Expected pipe with ID #{id} to be nil or closed")
     end
 

data/test/new_relic/agent/request_sampler_test.rb

@@ -0,0 +1,159 @@
+# -*- ruby -*-
+# 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/agent/request_sampler'
+
+class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
+
+  def setup
+    freeze_time
+    @event_listener = NewRelic::Agent::EventListener.new
+    @sampler = NewRelic::Agent::RequestSampler.new( @event_listener )
+  end
+
+  def test_samples_on_transaction_finished_event
+    with_sampler_config do
+      advance_time( 0.60 )
+      @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.095 )
+
+      assert_equal 1, @sampler.samples.length
+    end
+  end
+
+  def test_samples_on_transaction_finished_event_include_options
+    with_sampler_config do
+      advance_time( 0.60 )
+      @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.095, :foo => :bar )
+
+      assert_equal :bar, @sampler.samples.first[:foo]
+    end
+  end
+
+  def test_samples_at_the_correct_rate
+    with_sampler_config( :'request_sampler.sample_rate_ms' => 50 ) do
+      # 240 requests over 6 seconds => 120 samples
+      # with_debug_logging do
+      241.times do
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        advance_time( 0.025 )
+      end
+      # end
+
+      assert_equal 120, @sampler.samples.length
+      @sampler.samples.each do |sample|
+        assert_is_valid_transaction_sample( sample )
+      end
+      @sampler.samples.each_with_index do |sample, i|
+        next if i.zero?
+        seconds = sample['timestamp'] - @sampler.samples[i-1]['timestamp']
+        assert_in_delta( seconds, 0.050, 0.001 )
+      end
+    end
+  end
+
+  def test_downsamples_and_reduces_sample_rate_when_throttled
+    with_sampler_config( :'request_sampler.sample_rate_ms' => 50 ) do
+      240.times do
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        advance_time( 0.025 )
+      end
+
+      @sampler.throttle( 2 )
+
+      241.times do
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        advance_time( 0.025 )
+      end
+
+      assert_equal 120, @sampler.samples.length
+      @sampler.samples.each do |sample|
+        assert_is_valid_transaction_sample( sample )
+      end
+      @sampler.samples.each_with_index do |sample, i|
+        next if i.zero?
+        seconds = sample['timestamp'] - @sampler.samples[i-1]['timestamp']
+        assert_in_delta( seconds, 0.100, 0.026 )
+      end
+    end
+  end
+
+  def test_downsamples_and_reduces_sample_rate_when_throttled_multiple_times
+    with_sampler_config( :'request_sampler.sample_rate_ms' => 50 ) do
+      240.times do
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        advance_time( 0.025 )
+      end
+
+      @sampler.throttle( 2 )
+
+      240.times do
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        advance_time( 0.025 )
+      end
+
+      @sampler.throttle( 3 )
+
+      241.times do
+        @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+        advance_time( 0.025 )
+      end
+
+      assert_equal 120, @sampler.samples.length
+      @sampler.samples.each do |sample|
+        assert_is_valid_transaction_sample( sample )
+      end
+      @sampler.samples.each_with_index do |sample, i|
+        next if i.zero?
+        seconds = sample['timestamp'] - @sampler.samples[i-1]['timestamp']
+        assert_in_delta( seconds, 0.150, 0.051 )
+      end
+    end
+  end
+
+  def test_can_disable_sampling
+    with_sampler_config( :'request_sampler.enabled' => false ) do
+      @event_listener.notify( :transaction_finished, 'Controller/foo/bar', 0.200 )
+      assert @sampler.samples.empty?
+    end
+  end
+
+  def test_allows_sample_rates_as_frequent_as_25ms
+    with_config( :'request_sampler.sample_rate_ms' => 25 ) do
+      assert_equal 25, @sampler.normal_sample_rate_ms
+    end
+  end
+
+  def test_resets_sample_rates_more_frequent_than_25ms_to_25ms
+    with_config( :'request_sampler.sample_rate_ms' => 1 ) do
+      assert_equal 25, @sampler.normal_sample_rate_ms
+    end
+  end
+
+
+  #
+  # Helpers
+  #
+
+  def with_sampler_config(options = {})
+    defaults =
+    {
+      :'request_sampler.enabled' => true,
+      :'request_sampler.sample_rate_ms' => 50
+    }
+
+    defaults.merge!(options)
+    with_config(defaults) do
+      @event_listener.notify( :finished_configuring )
+      yield
+    end
+  end
+
+  def assert_is_valid_transaction_sample( sample )
+    assert_kind_of Hash, sample
+    assert_equal 'Transaction', sample['type']
+  end
+
+end

data/test/new_relic/agent/stats_engine/samplers_test.rb

@@ -27,7 +27,6 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
     samplers.add_harvest_sampler(sampler)
 
     assert_equal [sampler], samplers.harvest_samplers
-    assert_equal samplers, sampler.stats_engine
   end
 
   def test_cannot_add_harvest_sampler_twice
@@ -70,7 +69,6 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
 
   def test_memory__default
     s = NewRelic::Agent::Samplers::MemorySampler.new
-    s.stats_engine = @stats_engine
     s.poll
     s.poll
     s.poll
@@ -83,7 +81,6 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
     return if RUBY_PLATFORM =~ /darwin/
     NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'linux'
     s = NewRelic::Agent::Samplers::MemorySampler.new
-    s.stats_engine = @stats_engine
     s.poll
     s.poll
     s.poll
@@ -97,9 +94,8 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
     NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'solaris'
     NewRelic::Agent::Samplers::MemorySampler::ShellPS.any_instance.stubs(:get_memory).returns 999
     s = NewRelic::Agent::Samplers::MemorySampler.new
-    s.stats_engine = @stats_engine
     s.poll
-    stats = s.stats_engine.get_stats_no_scope("Memory/Physical")
+    stats = @stats_engine.get_stats_no_scope("Memory/Physical")
     assert_equal 1, stats.call_count
     assert_equal 999, stats.total_call_time
   end

data/test/new_relic/agent/stats_engine_test.rb

@@ -174,6 +174,20 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
     assert_equal 10, scope1.children_time.round
   end
 
+  def test_sampler_enabling
+    assert_sampler_enabled_with(true,  :'transaction_tracer.enabled' => true,  :developer_mode => false)
+    assert_sampler_enabled_with(true,  :'transaction_tracer.enabled' => false, :developer_mode => true)
+    assert_sampler_enabled_with(true,  :'transaction_tracer.enabled' => true,  :developer_mode => true)
+
+    assert_sampler_enabled_with(false, :'transaction_tracer.enabled' => false, :developer_mode => false)
+  end
+
+  def assert_sampler_enabled_with(expected, opts={})
+    with_config(opts) do
+      assert_equal expected, @engine.sampler_enabled?
+    end
+  end
+
   private
   def check_time_approximate(expected, actual)
     assert((expected - actual).abs < 0.1, "Expected between #{expected - 0.1} and #{expected + 0.1}, got #{actual}")

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -7,6 +7,7 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
 
   def setup
+    freeze_time
     @builder = NewRelic::Agent::TransactionSampleBuilder.new
   end
 
@@ -73,27 +74,27 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
   # this is really a test for transaction sample
   def test_omit_segments_with
     build_segment "Controller/my_controller/index" do
-      sleep 0.010
+      advance_time 0.010
 
       build_segment "Rails/Application Code Loading" do
-        sleep 0.020
+        advance_time 0.020
 
         build_segment "foo/bar" do
-          sleep 0.010
+          advance_time 0.010
         end
       end
 
       build_segment "a" do
         build_segment "ab"
-        sleep 0.010
+        advance_time 0.010
       end
       build_segment "b" do
         build_segment "ba"
-        sleep 0.05
+        advance_time 0.05
         build_segment "bb"
         build_segment "bc" do
           build_segment "bca"
-          sleep 0.05
+          advance_time 0.05
         end
       end
       build_segment "c"
@@ -169,6 +170,42 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
     end
   end
 
+  def test_trace_has_valid_durations_when_segments_limited
+    with_config(:'transaction_tracer.limit_segments' => 3) do
+      build_segment "parent" do
+        advance_time 1
+        build_segment "child-0.0" do
+          advance_time 1
+          build_segment "child-0.1" do
+            advance_time 1
+          end
+        end
+        advance_time 1
+        build_segment "child-1.0" do
+          advance_time 1
+          build_segment "child-1.1" do
+            advance_time 1
+          end
+        end
+      end
+
+      sample = @builder.sample
+      assert_equal(3, sample.count_segments)
+
+      segment_names = []
+      segment_durations = []
+      sample.each_segment do |s|
+        if s != sample.root_segment
+          segment_names << s.metric_name
+          segment_durations << s.duration
+        end
+      end
+
+      assert_equal(["parent", "child-0.0", "child-0.1"], segment_names)
+      assert_equal([6.0, 2.0, 1.0], segment_durations)
+    end
+  end
+
   def test_finish_trace_records_threshold
     NewRelic::Agent::TransactionInfo.get.stubs(:transaction_trace_threshold) \
       .returns(2.0)