sundawg_newrelic_rpm 3.5.8.1

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

@@ -0,0 +1,97 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+class NewRelic::Agent::Instrumentation::QueueTimeTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation
+
+  def test_parse_frontend_timestamp_given_queue_start_header
+    header = { 'HTTP_X_QUEUE_START' => format_header_time(Time.now - 60) }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+  end
+
+  def test_parse_frontend_timestamp_given_request_start_header
+    header = { 'HTTP_X_REQUEST_START' => format_header_time(Time.now - 60) }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+  end
+
+  def test_parse_frontend_timestamp_given_middleware_start_header
+    header = { 'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 60) }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+  end
+
+  def test_parse_frontend_timestamp_from_earliest_header
+    headers = { 'HTTP_X_REQUEST_START'    => format_header_time(Time.now - 63),
+                'HTTP_X_QUEUE_START'      => format_header_time(Time.now - 62),
+                'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 61)}
+
+    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.1)
+  end
+
+  def test_parse_frontend_timestamp_from_earliest_header_out_of_order
+    headers = { 'HTTP_X_MIDDLEWARE_START' => format_header_time(Time.now - 63),
+                'HTTP_X_REQUEST_START'    => format_header_time(Time.now - 62),
+                'HTTP_X_QUEUE_START'      => format_header_time(Time.now - 61) }
+
+    assert_in_delta(seconds_ago(63), QueueTime.parse_frontend_timestamp(headers), 0.1)
+  end
+
+  def test_parse_frontend_timestamp_from_header_in_seconds
+    header = { 'HTTP_X_QUEUE_START' => "t=#{Time.now.to_f - 60}" }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+  end
+
+  def test_parse_frontend_timestamp_from_header_in_milliseconds
+    header = { 'HTTP_X_QUEUE_START' => "t=#{(Time.now.to_f - 60) * 1_000}" }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+  end
+
+  def test_parse_frontend_timestamp_from_header_with_multiple_servers
+    now = Time.now.to_f
+    header = { 'HTTP_X_QUEUE_START' => "servera t=#{now - 60}, serverb t=#{now - 30}" }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+  end
+
+  def test_parse_frontend_timestamp_from_header_missing_t_equals
+    header = { 'HTTP_X_REQUEST_START' => (Time.now.to_f - 60).to_s }
+    assert_in_delta(seconds_ago(60), QueueTime.parse_frontend_timestamp(header), 0.1)
+  end
+
+  def test_parse_frontend_timestamp_from_header_negative
+    now = Time.now
+    the_future = Time.at(now.to_f + 60)
+    header = { 'HTTP_X_REQUEST_START' => the_future.to_f.to_s }
+    assert_in_delta(now, QueueTime.parse_frontend_timestamp(header, now), 0.1)
+  end
+
+  def test_recording_queue_time_metric
+    assert_metric_value_in_delta(60, 'WebFrontend/QueueTime', 0.1) do
+      QueueTime.record_frontend_metrics(Time.at(Time.now.to_f - 60))
+    end
+  end
+
+  def test_parsing_malformed_header
+    header = { 'HTTP_X_REQUEST_START' => 'gobledy gook' }
+
+    assert_nil QueueTime.parse_frontend_timestamp(header)
+  end
+
+  def test_parse_timestamp_can_identify_unit
+    now = Time.now.to_f
+    assert_in_delta(now, QueueTime.parse_timestamp(now.to_f.to_s).to_f, 0.001)
+    assert_in_delta(now, QueueTime.parse_timestamp((now.to_f * 1_000).to_s).to_f, 0.001)
+    assert_in_delta(now, QueueTime.parse_timestamp((now.to_f * 1_000_000).to_s).to_f, 0.001)
+  end
+
+  def format_header_time(time=Time.now)
+    "t=#{(time.to_f * 1_000_000).to_i}"
+  end
+
+  def seconds_ago(seconds)
+    Time.at(Time.now.to_f - seconds)
+  end
+
+  def assert_metric_value_in_delta(expected, metric_name, delta)
+    stats_engine = NewRelic::Agent.instance.stats_engine
+    stats_engine.clear_stats
+    yield
+    assert_in_delta(expected, stats_engine.get_stats(metric_name).total_call_time, delta)
+  end
+end

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

@@ -0,0 +1,35 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+require 'new_relic/agent/instrumentation/rack'
+
+class MinimalRackApp
+  def initialize(return_value)
+    @return_value = return_value
+  end
+
+  def call(env)
+    @return_value
+  end
+
+  include NewRelic::Agent::Instrumentation::Rack
+end
+
+class NewRelic::Agent::Instrumentation::RackTest < Test::Unit::TestCase
+
+  def test_basic_rack_app
+    # should return what we send in, even when instrumented
+    x = MinimalRackApp.new([200, {}, ["whee"]])
+    assert_equal [200, {}, ["whee"]], x.call({})
+  end
+
+  def test_basic_rack_app_404
+    x = MinimalRackApp.new([404, {}, ["whee"]])
+    assert_equal [404, {}, ["whee"]], x.call({})
+  end
+
+  def test_basic_rack_app_ignores_404
+    NewRelic::Agent::Instrumentation::MetricFrame.expects(:abort_transaction!)
+    x = MinimalRackApp.new([404, {}, ["whee"]])
+    assert_equal [404, {}, ["whee"]], x.call({})
+  end
+end
+

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

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+require 'new_relic/agent/instrumentation/sinatra'
+
+class NewRelic::Agent::Instrumentation::SinatraTest < Test::Unit::TestCase
+  class SinatraTestApp
+    def initialize(response)
+      @response = response
+    end
+
+    def dispatch!
+      @response = response
+    end
+
+    include NewRelic::Agent::Instrumentation::Sinatra
+    alias dispatch_without_newrelic dispatch!
+    alias dispatch! dispatch_with_newrelic
+  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
+  end
+end

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

@@ -0,0 +1,182 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_contexts'))
+
+class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  extend TestContexts
+  attr_accessor :agent
+
+  with_running_agent do
+
+    should "run" do
+      run_task_inner 0
+      stat_names = %w[Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0
+                    HttpDispatcher
+                    Apdex Apdex/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0].sort
+      expected_but_missing = stat_names - @agent.stats_engine.metrics
+      assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+      "#{'%-26s' % n}: #{stat.call_count} calls"
+      }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
+      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+    end
+
+    should "run_recursive" do
+      run_task_inner(3)
+      assert_equal 1, @agent.stats_engine.lookup_stats(
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
+      assert_equal 1, @agent.stats_engine.lookup_stats(
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2').call_count
+      assert_equal 1, @agent.stats_engine.lookup_stats(
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2',
+                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3').call_count
+      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
+    end
+
+    should "run_nested" do
+      run_task_outer(3)
+      @agent.stats_engine.metrics.sort.each do |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+      end
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
+      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+    end
+
+    should "reentrancy" do
+      assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
+      run_task_inner(1)
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
+      compare_metrics %w[
+      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0:Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1
+      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0
+      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1
+      ], @agent.stats_engine.metrics.grep(/^Controller/)
+    end
+
+    should "transaction" do
+      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+      assert_nil @agent.transaction_sampler.last_sample
+      assert_equal @agent.transaction_sampler, @agent.stats_engine.instance_variable_get("@transaction_sampler")
+      run_task_outer(10)
+      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+      @agent.stats_engine.metrics.sort.each do |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+      end
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
+      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
+      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
+      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+      sample = @agent.transaction_sampler.last_sample
+      assert_not_nil sample
+      assert_not_nil sample.params[:custom_params][:cpu_time], "cpu time nil: \n#{sample}"
+      assert sample.params[:custom_params][:cpu_time] >= 0, "cpu time: #{sample.params[:cpu_time]},\n#{sample}"
+      assert_equal '10', sample.params[:request_params][:level]
+    end
+
+    should "abort" do
+      @acct = 'Redrocks'
+      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+        self.class.inspect
+        NewRelic::Agent.abort_transaction!
+      end
+      # We record the controller metric still, but abort any transaction recording.
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello').call_count
+      assert_nil @agent.transaction_sampler.last_sample
+    end
+    should "block" do
+      assert_equal @agent, NewRelic::Agent.instance
+      @acct = 'Redrocks'
+      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
+        self.class.inspect
+      end
+      @agent.stats_engine.metrics.sort.each do |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+      end
+      assert_equal @agent, NewRelic::Agent.instance
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello').call_count
+      sample = @agent.transaction_sampler.last_sample
+      assert_not_nil sample
+      assert_equal 'Redrocks', sample.params[:request_params][:account]
+
+    end
+
+    should "error_handling" do
+      @agent.error_collector.ignore_error_filter
+      @agent.error_collector.harvest_errors([])
+      @agent.error_collector.expects(:notice_error).once
+      assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
+      assert_raise RuntimeError do
+        run_task_exception
+      end
+    end
+
+    should "custom_params" do
+      @agent.error_collector.stubs(:enabled).returns(true)
+      @agent.error_collector.ignore_error_filter
+      @agent.error_collector.harvest_errors([])
+      assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
+      assert_raise RuntimeError do
+        run_task_exception
+      end
+      errors = @agent.error_collector.harvest_errors([])
+      assert_equal 1, errors.size
+      error = errors.first
+      assert_equal "Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_task_exception", error.path
+      assert_not_nil error.params[:stack_trace]
+      assert_not_nil error.params[:custom_params]
+    end
+
+    should "instrument_bg" do
+      run_background_job
+      stat_names = %w[OtherTransaction/Background/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_background_job
+                    OtherTransaction/Background/all
+                    OtherTransaction/all].sort
+
+      expected_but_missing = stat_names - @agent.stats_engine.metrics
+      assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
+        stat = @agent.stats_engine.get_stats_no_scope(n)
+      "#{'%-26s' % n}: #{stat.call_count} calls"
+      }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/all').call_count
+      assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/Background/all').call_count
+    end
+  end
+
+  private
+
+  def run_task_inner(n)
+    return if n == 0
+    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
+    run_task_inner(n-1)
+  end
+
+  def run_task_outer(n=0)
+    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
+    run_task_inner(n)
+    run_task_inner(n)
+  end
+
+  def run_task_exception
+    NewRelic::Agent.add_custom_parameters(:custom_one => 'one custom val')
+    assert_equal 1, NewRelic::Agent::BusyCalculator.busy_count
+    raise "This is an error"
+  end
+
+  def run_background_job
+    "This is a background job"
+  end
+
+  add_transaction_tracer :run_task_exception
+  add_transaction_tracer :run_task_inner, :name => 'inner_task_#{args[0]}'
+  add_transaction_tracer :run_task_outer, :name => 'outer_task', :params => '{ :level => args[0] }'
+  # Eventually we need th change this to :category => :task
+  add_transaction_tracer :run_background_job, :category => 'OtherTransaction/Background'
+end

data/test/new_relic/agent/memcache_instrumentation_test.rb

@@ -0,0 +1,143 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+memcached_ready = false
+classes = {
+#   'memcache' => 'MemCache',
+#   'dalli' => 'Dalli::Client',
+  'memcached' => 'Memcached'
+#   'spymemcached' => 'Spymemcached'
+}
+begin
+  TCPSocket.new('localhost', 11211)
+  classes.each do |req, const|
+    begin
+      require req
+      MEMCACHED_CLASS = const.constantize
+      puts "Testing #{MEMCACHED_CLASS}"
+      memcached_ready = true
+    rescue LoadError
+    rescue NameError
+    end
+  end
+rescue Errno::ECONNREFUSED
+rescue Errno::ETIMEDOUT
+end
+
+class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  
+  def setup
+    NewRelic::Agent.manual_start
+    @engine = NewRelic::Agent.instance.stats_engine
+    
+    case MEMCACHED_CLASS.name
+    when 'Memcached'
+      @cache = MEMCACHED_CLASS.new('localhost', :support_cas => true)
+    when 'Spymemcached'
+      @cache = MEMCACHED_CLASS.new('localhost:11211')
+    else
+      @cache = MEMCACHED_CLASS.new('localhost')
+    end
+    @key = 'schluessel'
+    @cache.set('schluessel', 1)
+  end
+  
+  def teardown
+    if MEMCACHED_CLASS.name == 'Memcached'
+      @cache.flush
+    elsif MEMCACHED_CLASS.name == 'Spymemcached'
+      @cache.flush
+      @cache.instance_eval{ @client.shutdown }
+    else
+      @cache.flush_all
+    end
+  end
+  
+  def _call_test_method_in_web_transaction(method, *args)
+    @engine.clear_stats
+    perform_action_with_newrelic_trace(:name=>'action', :category => :controller) do
+      @cache.send(method.to_sym, *[@key, *args])
+    end
+  end
+
+  def _call_test_method_in_background_task(method, *args)
+    @engine.clear_stats
+    perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
+      @cache.send(method.to_sym, *[@key, *args])
+    end
+  end
+
+  def test_reads__web
+    commands = ['get']
+    commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
+    commands.each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_web_transaction(method)
+        compare_metrics ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
+        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+
+  def test_writes__web
+    %w[delete].each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_web_transaction(method)
+        expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+
+    %w[set add].each do |method|
+      @cache.delete(@key) rescue nil
+      if @cache.class.method_defined?(method)
+        expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        _call_test_method_in_web_transaction(method, 'value')
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+
+  def test_reads__background
+    commands = ['get']
+    commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
+    commands.each do |method|    
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method)
+        compare_metrics ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
+        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+
+  def test_writes__background
+    %w[delete].each do |method|
+      expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method)
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+
+    %w[set add].each do |method|
+      @cache.delete(@key) rescue nil
+      expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method, 'value')
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+
+  def test_handles_cas
+    expected_metrics = ["Memcache/cas", "Memcache/allOther", "Memcache/cas:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+    if @cache.class.method_defined?(:cas)
+      @engine.clear_stats
+      perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
+        @cache.cas(@key) {|val| val += 2 }
+      end
+      compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      assert_equal 3, @cache.get(@key)
+    end    
+  end  
+end if memcached_ready