wd_newrelic_rpm 3.5.6 → 3.5.8

data/test/new_relic/agent/cross_process_monitoring_test.rb

@@ -1,190 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-
-module NewRelic::Agent
-  class CrossProcessMonitorTest < Test::Unit::TestCase
-    AGENT_CROSS_PROCESS_ID = "qwerty"
-    REQUEST_CROSS_PROCESS_ID = "42#1234"
-
-    ENCODING_KEY_NOOP = "\0"
-    TRUSTED_ACCOUNT_IDS = [42,13]
-
-    CROSS_PROCESS_ID_POSITION = 0
-    TRANSACTION_NAME_POSITION = 1
-    QUEUE_TIME_POSITION = 2
-    APP_TIME_POSITION = 3
-    CONTENT_LENGTH_POSITION = 4
-
-    def setup
-      @response = {}
-
-      @monitor = NewRelic::Agent::CrossProcessMonitor.new()
-      @monitor.finish_setup(
-        :cross_process_id => AGENT_CROSS_PROCESS_ID,
-        :encoding_key => ENCODING_KEY_NOOP,
-        :trusted_account_ids => TRUSTED_ACCOUNT_IDS)
-    end
-
-    def when_request_runs(request=for_id(REQUEST_CROSS_PROCESS_ID))
-      @monitor.save_client_cross_process_id(request)
-      @monitor.set_transaction_custom_parameters
-      @monitor.insert_response_header(request, @response)
-    end
-
-    def when_request_has_error(request=for_id(REQUEST_CROSS_PROCESS_ID))
-      options = {}
-      @monitor.save_client_cross_process_id(request)
-      @monitor.set_error_custom_parameters(options)
-      @monitor.insert_response_header(request, @response)
-
-      options
-    end
-
-    def test_adds_response_header
-      with_default_timings
-
-      when_request_runs
-
-      assert_equal ["qwerty", "transaction", 1000, 2000, -1], unpacked_response
-    end
-
-    def test_strips_bad_characters_in_transaction_name
-      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(stub(
-          :transaction_name => "\"'goo",
-          :queue_time_in_seconds => 1000,
-          :app_time_in_seconds => 2000))
-
-      when_request_runs
-
-      assert_equal "goo", unpacked_response[TRANSACTION_NAME_POSITION]
-    end
-
-    def test_doesnt_write_response_header_if_id_blank
-      with_default_timings
-
-      when_request_runs(for_id(''))
-      assert_nil response_app_data
-    end
-
-    def test_doesnt_write_response_header_if_untrusted_id
-      with_default_timings
-
-      when_request_runs(for_id("4#1234"))
-      assert_nil response_app_data
-    end
-
-    def test_doesnt_write_response_header_if_improperly_formatted_id
-      with_default_timings
-
-      when_request_runs(for_id("42"))
-      assert_nil response_app_data
-    end
-
-    def test_doesnt_add_header_if_no_id_in_request
-      when_request_runs({})
-      assert_nil response_app_data
-    end
-
-    def test_doesnt_add_header_if_no_id_on_agent
-      @monitor.finish_setup(
-        :cross_process_id => nil,
-        :encoding_key => ENCODING_KEY_NOOP,
-        :trusted_account_ids => TRUSTED_ACCOUNT_IDS)
-
-      when_request_runs
-      assert_nil response_app_data
-    end
-
-    def test_doesnt_add_header_if_config_disabled
-      with_config(:'cross_process.enabled' => false) do
-        when_request_runs
-        assert_nil response_app_data
-      end
-    end
-
-    def test_includes_content_length
-      with_default_timings
-
-      when_request_runs(for_id(REQUEST_CROSS_PROCESS_ID).merge("Content-Length" => 3000))
-      assert_equal 3000, unpacked_response[CONTENT_LENGTH_POSITION]
-    end
-
-    def test_finds_content_length_from_headers
-      %w{Content-Length HTTP_CONTENT_LENGTH CONTENT_LENGTH cOnTeNt-LeNgTh}.each do |key|
-        request = { key => 42 }
-
-        assert_equal(42, @monitor.content_length_from_request(request), \
-          "Failed to find header on key #{key}")
-      end
-    end
-
-    def test_writes_custom_parameters
-      with_default_timings
-
-      NewRelic::Agent.expects(:add_custom_parameters).once
-
-      when_request_runs
-    end
-
-    def test_error_writes_custom_parameters
-      with_default_timings
-
-      options = when_request_has_error
-
-      assert_equal REQUEST_CROSS_PROCESS_ID, options[:client_cross_process_id]
-    end
-
-    def test_error_doesnt_write_custom_parameters_if_no_id
-      with_default_timings
-
-      options = when_request_has_error(for_id(''))
-
-      assert_equal false, options.key?(:client_cross_process_id)
-    end
-
-    def test_writes_metric
-      with_default_timings
-
-      metric = mock()
-      metric.expects(:record_data_point).with(2000)
-      NewRelic::Agent.instance.stats_engine.stubs(:get_stats_no_scope).returns(metric)
-
-      when_request_runs
-    end
-
-    def test_doesnt_write_metric_if_id_blank
-      with_default_timings
-      NewRelic::Agent.instance.stats_engine.expects(:get_stats_no_scope).never
-
-      when_request_runs(for_id(''))
-    end
-
-    def test_decoding_blank
-      assert_equal "", @monitor.decode_with_key("")
-    end
-
-    def test_get_bytes_with_nil
-      assert_equal [], @monitor.send(:get_bytes, nil)
-    end
-
-    def with_default_timings
-      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(stub(
-          :transaction_name => "transaction",
-          :queue_time_in_seconds => 1000,
-          :app_time_in_seconds => 2000))
-    end
-
-    def for_id(id)
-      encoded_id = id == "" ? "" : Base64.encode64(id)
-      { 'X-NewRelic-ID' => encoded_id }
-    end
-
-    def response_app_data
-      @response['X-NewRelic-App-Data']
-    end
-
-    def unpacked_response
-      # Assumes array is valid JSON and Ruby, which is currently is
-      eval(Base64.decode64(response_app_data))
-    end
-  end
-end

data/test/new_relic/agent/stats_engine/metric_stats/harvest_test.rb

@@ -1,133 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
-require 'new_relic/agent/stats_engine/metric_stats'
-
-class NewRelic::Agent::StatsEngine::MetricStats::HarvestTest < Test::Unit::TestCase
-  include NewRelic::Agent::StatsEngine::MetricStats::Harvest
-
-  attr_accessor :stats_hash
-  def test_merge_stats_with_nil_stats
-    self.stats_hash = NewRelic::Agent::StatsEngine::MetricStats::SynchronizedHash.new
-    assert_equal({}, merge_stats({}, {}))
-  end
-
-
-  def test_get_stats_hash_from_hash
-    assert_equal({}, get_stats_hash_from({}))
-  end
-
-  def test_get_stats_hash_from_engine
-    assert_equal({}, get_stats_hash_from(NewRelic::Agent::StatsEngine.new))
-  end
-
-  def test_coerce_to_metric_spec_metric_spec
-    assert_equal NewRelic::MetricSpec.new, coerce_to_metric_spec(NewRelic::MetricSpec.new)
-  end
-
-  def test_coerce_to_metric_spec_string
-    assert_equal NewRelic::MetricSpec.new('foo'), coerce_to_metric_spec('foo')
-  end
-
-  def test_clone_and_reset_stats_nil
-    spec = NewRelic::MetricSpec.new('foo', 'bar')
-    stats = nil
-    begin
-      clone_and_reset_stats(spec, stats)
-    rescue RuntimeError => e
-      assert_equal("Nil stats for foo (bar)", e.message)
-    end
-  end
-
-  def test_clone_and_reset_stats_present
-    # spec is only used for debug output
-    spec = nil
-    stats = mock('stats')
-    stats_clone = mock('stats_clone')
-    stats.expects(:clone).returns(stats_clone)
-    stats.expects(:reset)
-    # should return a clone
-    assert_equal stats_clone, clone_and_reset_stats(spec, stats)
-  end
-
-  def test_merge_old_data_present
-    metric_spec = mock('metric_spec')
-    stats = mock('stats obj')
-    stats.expects(:merge!).with('some stats')
-    old_data = mock('old data')
-    old_data.expects(:stats).returns('some stats')
-    old_data_hash = {metric_spec => old_data}
-    merge_old_data!(metric_spec, stats, old_data_hash)
-  end
-
-  def test_merge_old_data_nil
-    metric_spec = mock('metric_spec')
-    stats = mock('stats') # doesn't matter
-    old_data_hash = {metric_spec => nil}
-    merge_old_data!(metric_spec, stats, old_data_hash)
-  end
-
-  def test_add_data_to_send_unless_empty_when_is_empty
-    stats = mock('stats')
-    stats.expects(:is_reset?).returns(true)
-    assert_equal nil, add_data_to_send_unless_empty(nil, stats, nil, nil)
-  end
-
-  def test_add_data_to_send_unless_empty_main
-    data = mock('data hash')
-    stats = mock('stats')
-    stats.expects(:is_reset?).returns(false)
-    metric_spec = mock('spec')
-
-    NewRelic::MetricData.expects(:new).with(metric_spec, stats, nil).returns('metric data')
-    data.expects(:[]=).with(metric_spec, 'metric data')
-    add_data_to_send_unless_empty(data, stats, metric_spec, nil)
-  end
-
-  def test_add_data_to_send_unless_empty_with_id
-    data = mock('data hash')
-    stats = mock('stats')
-    stats.expects(:is_reset?).returns(false)
-    metric_spec = mock('spec')
-    id = mock('id')
-
-    NewRelic::MetricData.expects(:new).with(nil, stats, id).returns('metric data')
-    data.expects(:[]=).with(metric_spec, 'metric data')
-    assert_equal 'metric data', add_data_to_send_unless_empty(data, stats, metric_spec, id)
-  end
-
-  def test_merge_data_basic
-    mock_stats_hash = mock('stats hash')
-    self.stats_hash = mock_stats_hash
-    merge_data({})
-  end
-
-  def test_merge_data_new_and_old_data
-    stats = NewRelic::MethodTraceStats.new
-    stats.record_data_point(1.0)
-    new_stats = NewRelic::MethodTraceStats.new
-    new_stats.record_data_point(2.0)
-    self.expects(:lookup_stats).with('Custom/test/method', '').returns(new_stats)
-    assert_equal(2.0, new_stats.total_call_time)
-
-    metric_spec = NewRelic::MetricSpec.new('Custom/test/method')
-    mock_stats_hash = mock('stats_hash')
-    self.stats_hash = mock_stats_hash
-    merge_data({metric_spec => NewRelic::MetricData.new(metric_spec, stats, nil)})
-    assert_equal(3.0, new_stats.total_call_time)
-  end
-
-  def test_merge_data_old_data
-    stats = NewRelic::MethodTraceStats.new
-    stats.record_data_point(1.0)
-    self.expects(:lookup_stats).returns(nil)
-
-    metric_spec = NewRelic::MetricSpec.new('Custom/test/method')
-    mock_stats_hash = mock('stats_hash')
-    mock_stats_hash.expects(:[]=).with(metric_spec, stats)
-    self.stats_hash = mock_stats_hash
-    merge_data({metric_spec => NewRelic::MetricData.new(metric_spec, stats, nil)})
-  end
-
-end
-
-
-

data/test/new_relic/fakes_sending_data.rb

@@ -1,30 +0,0 @@
-module NewRelic
-  module FakesSendingData
-    def calls_for(method)
-      @agent_data. \
-        select { |d| d.action == method }. \
-        map { |d| d.body }
-    end
-
-    # Unpeel the inner layers of encoding applied by the JSON marshaller.
-    # I'm sorry.
-    def unpack_inner_blobs(req)
-      body = req.body
-      if req.format == :json
-        case req.action
-        when 'profile_data' then
-          body[0][4] = unpack(body[0][4])
-        when 'sql_trace_data' then
-          body[0][0][9] = unpack(body[0][0][9])
-        when 'transaction_sample_data' then
-          body[4] = unpack(body[4])
-        end
-      end
-      body
-    end
-
-    def unpack(blob)
-      JSON.load(Zlib::Inflate.inflate(Base64.decode64(blob)))
-    end
-  end
-end

data/test/new_relic/stats_test.rb

@@ -1,421 +0,0 @@
-ENV['SKIP_RAILS'] = 'true'
-require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
-##require "new_relic/stats"
-
-module NewRelic; class TestObjectForStats
-                   include Stats
-                   attr_accessor :total_call_time
-                   attr_accessor :total_exclusive_time
-                   attr_accessor :begin_time
-                   attr_accessor :end_time
-                   attr_accessor :call_count
-end; end
-
-
-class NewRelic::StatsTest < Test::Unit::TestCase
-
-  def test_checked_calculation_standard
-    obj = NewRelic::TestObjectForStats.new
-
-    assert_equal(1.0, obj.checked_calculation(1, 1))
-
-  end
-
-  def test_checked_calculation_with_zero
-    obj = NewRelic::TestObjectForStats.new
-    assert_equal(0.0, obj.checked_calculation(1, 0))
-  end
-
-  def test_checked_calculation_should_return_floats
-    obj = NewRelic::TestObjectForStats.new
-    assert_equal(0.5, obj.checked_calculation(1, 2))
-  end
-
-  def test_sum_attributes
-    first  = NewRelic::TestObjectForStats.new
-    second = mock('other object')
-    first.expects(:call_count).returns(6)
-    second.expects(:call_count).returns(8)
-    first.expects(:update_totals).with(second)
-    first.expects(:stack_min_max_from).with(second)
-    first.expects(:update_boundaries).with(second)
-    first.expects(:call_count=).with(8)
-    first.sum_attributes(second)
-  end
-
-  def mock_plusequals(first, second, method, first_value, second_value)
-    first.expects(method).returns(first_value)
-    second.expects(method).returns(second_value)
-    first.expects("#{method}=".to_sym).with(first_value + second_value)
-  end
-
-  def test_stack_min_max_from
-    first  = NewRelic::TestObjectForStats.new
-    second = mock('other object')
-    mock_plusequals(first, second, :min_call_time, 1.5, 0.5)
-    mock_plusequals(first, second, :max_call_time, 1.0, 3.0)
-
-    first.stack_min_max_from(second)
-  end
-
-  def test_update_boundaries
-    first  = NewRelic::TestObjectForStats.new
-    second = mock('other object')
-
-    first.expects(:should_replace_begin_time?).with(second).returns(true)
-    first.expects(:should_replace_end_time?).with(second).returns(true)
-    first.expects(:begin_time=).with('other_begin_time')
-    first.expects(:end_time=).with('other_end_time')
-
-    second.expects(:begin_time).returns('other_begin_time')
-    second.expects(:end_time).returns('other_end_time')
-    first.update_boundaries(second)
-  end
-
-  def test_should_replace_end_time
-    first  = NewRelic::TestObjectForStats.new
-    second = mock('other object')
-
-    first.expects(:end_time).returns(Time.at(1))
-    second.expects(:end_time).returns(Time.at(2))
-    assert first.should_replace_end_time?(second), 'should replace end time when the other stat is larger'
-  end
-
-  def test_should_replace_begin_time_base
-    first  = NewRelic::TestObjectForStats.new
-    second = mock('other object')
-
-    first.expects(:begin_time).returns(Time.at(2))
-    second.expects(:begin_time).returns(Time.at(1))
-
-    assert first.should_replace_begin_time?(second), 'should replace the begin time when it is larger'
-  end
-
-  def test_should_replace_begin_time_empty
-    first = NewRelic::TestObjectForStats.new
-    second = mock('other object')
-
-    first.expects(:begin_time).returns(Time.at(0))
-    second.expects(:begin_time).returns(Time.at(2))
-
-    first.expects(:begin_time).returns(Time.at(0))
-
-    assert first.should_replace_begin_time?(second), "should replace the begin time if self.call_count == 0"
-  end
-
-  def test_update_totals
-    first = NewRelic::TestObjectForStats.new
-    second = mock('other object')
-
-    [:total_call_time, :total_exclusive_time, :sum_of_squares].each do |method|
-      mock_plusequals(first, second, method, 2.0, 3.0)
-    end
-
-    first.update_totals(second)
-  end
-
-  def test_min_time_less
-    first = NewRelic::TestObjectForStats.new
-    second = mock('other object')
-
-    second.expects(:min_call_time).returns(1.0)
-    first.expects(:min_call_time).returns(2.0)
-    second.expects(:call_count).returns(1)
-
-    first.min_time_less?(second)
-  end
-
-  def test_expand_min_max_to
-    first = NewRelic::TestObjectForStats.new
-    second = mock('other object')
-
-    first.expects(:min_time_less?).with(second).returns(true)
-    first.expects(:max_call_time).returns(3.0)
-
-    second.expects(:min_call_time).returns(1.0)
-    second.expects(:max_call_time).returns(4.0).twice
-
-    first.expects(:min_call_time=).with(1.0)
-    first.expects(:max_call_time=).with(4.0)
-
-    first.expand_min_max_to(second)
-  end
-
-
-
-  def test_simple
-    stats = NewRelic::MethodTraceStats.new
-    validate stats, 0, 0, 0, 0
-
-    assert_equal stats.call_count,0
-    stats.trace_call 10
-    stats.trace_call 20
-    stats.trace_call 30
-
-    validate stats, 3, (10+20+30), 10, 30
-  end
-
-  def test_to_s
-    s1 = NewRelic::MethodTraceStats.new
-    s1.trace_call 10
-    assert_equal("[01/01/70 12:00AM UTC, 0.000s;  1 calls   10s]", s1.to_s)
-  end
-
-  def test_time_str
-    s1 = NewRelic::MethodTraceStats.new
-    assert_equal(s1.time_str(10), "10 ms")
-    assert_equal(s1.time_str(4999), "4999 ms")
-    assert_equal(s1.time_str(5000), "5.00 s")
-    assert_equal(s1.time_str(5010), "5.01 s")
-    assert_equal(s1.time_str(9999), "10.00 s")
-    assert_equal(s1.time_str(10000), "10.0 s")
-    assert_equal(s1.time_str(20000), "20.0 s")
-  end
-
-  def test_multiply_by
-    s1 = NewRelic::MethodTraceStats.new
-    s1.trace_call 10
-    assert_equal("[01/01/70 12:00AM UTC, 0.000s; 10 calls   10s]", s1.multiply_by(10).to_s)
-  end
-
-  def test_get_apdex
-    s1 = NewRelic::MethodTraceStats.new
-    s1.trace_call 10
-    assert_equal(s1.get_apdex, [1, 10, 10])
-  end
-
-  def test_apdex_score
-    s1 = NewRelic::MethodTraceStats.new
-    s1.trace_call 10
-    assert_in_delta(s1.apdex_score, 0.285714285714286, 0.0000001)
-  end
-
-  def test_as_percentage
-    s1 = NewRelic::MethodTraceStats.new
-    s1.trace_call 10
-    assert_equal(s1.as_percentage, 1000.0)
-  end
-
-  def test_calls_per_minute
-
-    s1 = NewRelic::TestObjectForStats.new
-    s1.call_count =  1
-    s1.begin_time = Time.at(0)
-    s1.end_time = Time.at(30)
-    assert_equal(s1.calls_per_minute, 2)
-  end
-
-  def test_total_call_time_per_minute
-    s1 = NewRelic::TestObjectForStats.new
-    s1.begin_time = Time.at(0)
-    s1.end_time = Time.at(0)
-    assert_equal(0, s1.total_call_time_per_minute)
-    s1.begin_time = Time.at(0)
-    s1.end_time = Time.at(30)
-    s1.total_call_time = 10
-    assert_equal(20, s1.total_call_time_per_minute)
-  end
-
-  def test_time_percentage
-    s1 = NewRelic::TestObjectForStats.new
-    s1.begin_time = Time.at(0)
-    s1.end_time = Time.at(0)
-    assert_equal(0, s1.time_percentage)
-    s1.total_call_time = 10
-    s1.begin_time = Time.at(0)
-    s1.end_time = Time.at(30)
-    assert_equal((1.0 / 3.0), s1.time_percentage)
-    s1.total_call_time = 20
-    assert_equal((2.0 / 3.0), s1.time_percentage)
-  end
-
-  def test_exclusive_time_percentage
-    s1 = NewRelic::TestObjectForStats.new
-    s1.begin_time = Time.at(0)
-    s1.end_time = Time.at(0)
-    assert_equal(0, s1.exclusive_time_percentage)
-    s1.total_exclusive_time = 10
-    s1.begin_time = Time.at(0)
-    s1.end_time = Time.at(30)
-    assert_equal((1.0 / 3.0), s1.exclusive_time_percentage)
-    s1.total_exclusive_time = 20
-    assert_equal((2.0 / 3.0), s1.exclusive_time_percentage)
-  end
-
-  def test_sum_merge
-    s1 = NewRelic::MethodTraceStats.new
-    s2 = NewRelic::MethodTraceStats.new
-    s1.trace_call 10
-    s2.trace_call 20
-    s2.freeze
-
-    validate s1, 1, 10, 10, 10
-    validate s2, 1, 20, 20, 20
-    s1.sum_merge! s2
-    validate s1, 1, (10+20), 10 + 20, 20 + 10
-    validate s2, 1, 20, 20, 20
-  end
-
-  def test_sum_merge_with_exclusive
-    s1 = NewRelic::MethodTraceStats.new
-    s2 = NewRelic::MethodTraceStats.new
-
-    s1.trace_call 10, 5
-    s2.trace_call 20, 10
-    s2.freeze
-
-    validate s1, 1, 10, 10, 10, 5
-    validate s2, 1, 20, 20, 20, 10
-    s1.sum_merge! s2
-    validate s1, 1, (10+20), 10 + 20, 20 + 10, (10+5)
-  end
-
-  def test_merge
-    s1 = NewRelic::MethodTraceStats.new
-    s2 = NewRelic::MethodTraceStats.new
-
-    s1.trace_call 10
-    s2.trace_call 20
-    s2.freeze
-
-    validate s2, 1, 20, 20, 20
-    s3 = s1.merge s2
-    validate s3, 2, (10+20), 10, 20
-    validate s1, 1, 10, 10, 10
-    validate s2, 1, 20, 20, 20
-
-    s1.merge! s2
-    validate s1, 2, (10+20), 10, 20
-    validate s2, 1, 20, 20, 20
-  end
-
-  def test_merge_with_exclusive
-    s1 = NewRelic::MethodTraceStats.new
-
-    s2 = NewRelic::MethodTraceStats.new
-
-    s1.trace_call 10, 5
-    s2.trace_call 20, 10
-    s2.freeze
-
-    validate s2, 1, 20, 20, 20, 10
-    s3 = s1.merge s2
-    validate s3, 2, (10+20), 10, 20, (10+5)
-    validate s1, 1, 10, 10, 10, 5
-    validate s2, 1, 20, 20, 20, 10
-
-    s1.merge! s2
-    validate s1, 2, (10+20), 10, 20, (5+10)
-    validate s2, 1, 20, 20, 20, 10
-  end
-
-  def test_merge_array
-    s1 = NewRelic::MethodTraceStats.new
-    merges = []
-    merges << (NewRelic::MethodTraceStats.new.trace_call 1)
-    merges << (NewRelic::MethodTraceStats.new.trace_call 1)
-    merges << (NewRelic::MethodTraceStats.new.trace_call 1)
-
-    s1.merge! merges
-    validate s1, 3, 3, 1, 1
-  end
-
-  def test_freeze
-    s1 = NewRelic::MethodTraceStats.new
-
-    s1.trace_call 10
-    s1.freeze
-
-    begin
-      # the following should throw an exception because s1 is frozen
-      s1.trace_call 20
-      assert false
-    rescue StandardError
-      assert s1.frozen?
-      validate s1, 1, 10, 10, 10
-    end
-  end
-
-  def test_std_dev
-    s = NewRelic::MethodTraceStats.new
-    s.trace_call 1
-    assert s.standard_deviation == 0
-
-    s = NewRelic::MethodTraceStats.new
-    s.trace_call 10
-    s.trace_call 10
-    s.sum_of_squares = nil
-    assert s.standard_deviation == 0
-
-    s = NewRelic::MethodTraceStats.new
-    s.trace_call 0.001
-    s.trace_call 0.001
-    assert s.standard_deviation == 0
-
-
-    s = NewRelic::MethodTraceStats.new
-    s.trace_call 10
-    s.trace_call 10
-    s.trace_call 10
-    s.trace_call 10
-    s.trace_call 10
-    s.trace_call 10
-    assert s.standard_deviation == 0
-
-    s = NewRelic::MethodTraceStats.new
-    s.trace_call 4
-    s.trace_call 7
-    s.trace_call 13
-    s.trace_call 16
-    s.trace_call 8
-    s.trace_call 4
-    assert_equal(s.sum_of_squares, 4**2 + 7**2 + 13**2 + 16**2 + 8**2 + 4**2)
-
-    s.trace_call 9
-    s.trace_call 3
-    s.trace_call 1000
-    s.trace_call 4
-
-    # calculated stdev (population, not sample) from a spreadsheet.
-    assert_in_delta(s.standard_deviation, 297.76, 0.01)
-  end
-
-  def test_std_dev_merge
-    s1 = NewRelic::MethodTraceStats.new
-    s1.trace_call 4
-    s1.trace_call 7
-
-    s2 = NewRelic::MethodTraceStats.new
-    s2.trace_call 13
-    s2.trace_call 16
-
-    s3 = s1.merge(s2)
-
-    assert_equal(s1.sum_of_squares, 4*4 + 7*7)
-    assert_in_delta(s1.standard_deviation, 1.5, 0.01)
-
-    assert_in_delta(s2.standard_deviation, 1.5, 0.01)
-    assert_equal(s3.sum_of_squares, 4*4 + 7*7 + 13*13 + 16*16, "check sum of squares")
-    assert_in_delta(s3.standard_deviation, 4.743, 0.01)
-  end
-
-  if RUBY_VERSION >= '1.9'
-    def test_to_json_enforces_float_values
-      s1 = NewRelic::MethodTraceStats.new
-      s1.trace_call 3.to_r
-      s1.trace_call 7.to_r
-
-      assert_equal 3.0, JSON.load(s1.to_json)['min_call_time']
-    end
-  end
-
-  private
-  def validate (stats, count, total, min, max, exclusive = nil)
-    assert_equal stats.call_count, count
-    assert_equal stats.total_call_time, total
-    assert_equal stats.average_call_time, (count > 0 ? total / count : 0)
-    assert_equal stats.min_call_time, min
-    assert_equal stats.max_call_time, max
-    assert_equal stats.total_exclusive_time, exclusive if exclusive
-  end
-end