sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/framework_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+
+# Test logic around detecting or configuring framework
+class FrameworkTest < Test::Unit::TestCase
+
+  def setup
+
+    # muck with this constant which forces the agent to load the
+    # NewRelic::Control::Frameworks::Test control so we can test the logic used
+    # to load the appropriate control object.
+    @old_newrelic_test_const = ::NewRelic::TEST
+    ::NewRelic.send(:remove_const, :TEST)
+
+    NewRelic::Agent.shutdown
+    NewRelic::Agent.reset_config
+
+    # don't bomb out trying to load frameworks that don't exist.
+    NewRelic::Control.stubs(:new_instance).returns(stub :init_plugin => nil)
+  end
+
+  def teardown
+    # Put things back how we found them
+    ::NewRelic.send(:const_set, :TEST,  @old_newrelic_test_const)
+  end
+
+  def test_detects_framework_via_loaded_libraries
+    class << self
+      module ::Merb
+        module Plugins
+        end
+      end
+    end
+    assert_equal :merb, NewRelic::Agent.config[:framework]
+  ensure
+    Object.send(:remove_const, :Merb)
+  end
+
+  def test_detects_framework_via_ENV_NEW_RELIC_FRAMEWORK
+    ENV['NEW_RELIC_FRAMEWORK'] = "foobared"
+    NewRelic::Agent.reset_config
+    assert_equal :foobared, NewRelic::Agent.config[:framework]
+  ensure
+    ENV['NEW_RELIC_FRAMEWORK'] = nil
+  end
+
+  def test_detects_framework_via_ENV_NEWRELIC_FRAMEWORK
+    ENV['NEWRELIC_FRAMEWORK'] = "bazbang"
+    NewRelic::Agent.reset_config
+    assert_equal :bazbang, NewRelic::Agent.config[:framework]
+  ensure
+    ENV['NEWRELIC_FRAMEWORK'] = nil
+  end
+end

data/test/new_relic/helper_test.rb

@@ -0,0 +1,24 @@
+#encoding: utf-8
+
+#require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'test/unit'
+require 'newrelic_rpm'
+
+class HelperTest < Test::Unit::TestCase
+
+  def test_json_serializer_method
+    obj = [
+      99, 'luftballons',
+      {
+        'Hast du etwas' => 'Zeit für mich',
+        'Dann singe ich' => {
+          'ein lied' => 'für dich'
+        }
+      }
+    ]
+    copy = NewRelic.json_load( NewRelic.json_dump(obj) )
+
+    assert( obj == copy )
+  end
+
+end

data/test/new_relic/load_test.rb

@@ -0,0 +1,13 @@
+# require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'test/unit'
+require 'resolv'
+require 'mocha'
+
+class LoadTest < Test::Unit::TestCase
+  def test_loading_agent_when_disabled_does_not_resolv_addresses
+    ::Resolv.expects(:getaddress).never
+    ::IPSocket.expects(:getaddress).never
+
+    require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+  end
+end

data/test/new_relic/local_environment_test.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
+
+  def self.teardown
+    # To remove mock server instances from ObjectSpace
+    ObjectSpace.garbage_collect
+    super
+  end
+  class MockOptions
+    def fetch (*args)
+      1000
+    end
+  end
+  MOCK_OPTIONS = MockOptions.new
+
+#  def test_environment
+#    e = NewRelic::LocalEnvironment.new
+#    assert(nil == e.environment) # working around a bug in 1.9.1
+#    assert_match /test/i, e.dispatcher_instance_id
+#  end
+#  def test_no_webrick
+#    Object.const_set :OPTIONS, 'foo'
+#    e = NewRelic::LocalEnvironment.new
+#    assert(nil == e.environment) # working around a bug in 1.9.1
+#    assert_match /test/i, e.dispatcher_instance_id
+#    Object.class_eval { remove_const :OPTIONS }
+#  end
+
+  def test_passenger
+    class << self
+      module ::PhusionPassenger
+      end
+    end
+    NewRelic::Agent.reset_config
+    e = NewRelic::LocalEnvironment.new
+    assert_equal :passenger, e.discovered_dispatcher
+    assert_equal :passenger, NewRelic::Agent.config[:dispatcher]
+    assert_nil e.dispatcher_instance_id, "dispatcher instance id should be nil: #{e.dispatcher_instance_id}"
+
+    with_config(:app_name => 'myapp') do
+      e = NewRelic::LocalEnvironment.new
+      assert_equal :passenger, e.discovered_dispatcher
+      assert_nil e.dispatcher_instance_id
+    end
+
+  ensure
+    Object.send(:remove_const, :PhusionPassenger)
+  end
+
+  def test_snapshot
+    e = NewRelic::LocalEnvironment.new
+    s = e.snapshot
+    assert_equal 0, s.size
+    e.gather_environment_info
+    s = e.snapshot
+    assert_match /1\.8\.[67]|1\.9\.|2\.0/, s.assoc('Ruby version').last, s.inspect
+    assert_equal 'test', s.assoc('Framework').last, s.inspect
+    # Make sure the processor count is determined on linux systems
+    if File.exists? '/proc/cpuinfo'
+      assert s.assoc('Processors').last.to_i > 0
+    end
+  end
+
+  def test_gather_cpu_info_successful
+    e = NewRelic::LocalEnvironment.new
+    e.gather_cpu_info(File.expand_path(File.join(File.dirname(__FILE__),'..', 'fixtures', 'proc_cpuinfo.txt')))
+    s = e.snapshot
+    assert_equal 24, s.assoc('Processors').last.to_i
+  end
+
+  def test_gather_cpu_info_failure
+    e = NewRelic::LocalEnvironment.new
+    e.gather_cpu_info(File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper.rb')))
+    s = e.snapshot
+    assert_equal 1, s.assoc('Processors').last.to_i    
+  end
+
+  def test_default_port
+    e = NewRelic::LocalEnvironment.new
+    assert_equal 3000, e.send(:default_port)
+    ARGV.push '--port=3121'
+    assert_equal '3121', e.send(:default_port)
+    ARGV.pop
+  end
+end

data/test/new_relic/metric_data_test.rb

@@ -0,0 +1,183 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+require 'new_relic/metric_data'
+class NewRelic::MetricDataTest < Test::Unit::TestCase
+  def test_initialize_basic
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md = NewRelic::MetricData.new(spec, stats, metric_id)
+    assert_equal spec, md.metric_spec
+    assert_equal stats, md.stats
+    assert_equal metric_id, md.metric_id
+  end
+
+  def test_eql_basic
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    md2 = NewRelic::MetricData.new(spec, stats, metric_id)
+    assert(md1.eql?(md2), "The example metric data objects should be eql?: #{md1.inspect} #{md2.inspect}")
+    assert(md2.eql?(md1), "The example metric data objects should be eql?: #{md1.inspect} #{md2.inspect}")
+  end
+
+  def test_eql_unequal_specs
+    spec = mock('metric_spec')
+    other_spec = mock('other_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    md2 = NewRelic::MetricData.new(other_spec, stats, metric_id)
+    assert(!md1.eql?(md2), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+  end
+  def test_eql_unequal_stats
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    other_stats = mock('other_stats')
+    metric_id = mock('metric_id')
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    md2 = NewRelic::MetricData.new(spec, other_stats, metric_id)
+    assert(!md1.eql?(md2), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+    assert(!md2.eql?(md1), "The example metric data objects should not be eql?: #{md1.inspect} #{md2.inspect}")
+  end
+
+  def test_eql_unequal_metric_ids_dont_matter
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    other_metric_id = mock('other_metric_id')
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    md2 = NewRelic::MetricData.new(spec, stats, other_metric_id)
+    assert(md1.eql?(md2), "The example metric data objects should be eql? with different metric_ids: #{md1.inspect} #{md2.inspect}")
+    assert(md2.eql?(md1), "The example metric data objects should be eql? with different metric_ids: #{md1.inspect} #{md2.inspect}")
+  end
+
+  def test_original_spec_basic
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
+    assert_equal(spec, md1.metric_spec, "should return the metric spec for original spec when original spec is nil, but was #{md1.original_spec}")
+  end
+
+  def test_metric_spec_equal_should_not_set_original_spec_with_no_metric_spec
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = NewRelic::MetricData.new(nil, stats, metric_id)
+    original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
+
+    new_spec = mock('new metric_spec')
+    assert_equal(new_spec, md1.metric_spec=(new_spec), "should return the new spec")
+
+    new_original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, new_original_spec, "should not set @original_spec  but was #{new_original_spec.inspect}")
+  end
+
+  def test_metric_spec_equal_should_set_original_spec_with_existing_metric_spec
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(nil, original_spec, "should start with a nil original spec, but was #{original_spec.inspect}")
+
+    new_spec = mock('new metric_spec')
+    assert_equal(new_spec, md1.metric_spec=(new_spec), "should return the new spec")
+
+    new_original_spec = md1.instance_variable_get('@original_spec')
+    assert_equal(spec, new_original_spec, "should set @original_spec to the existing metric_spec  but was #{new_original_spec.inspect}")
+  end
+
+  def test_hash
+    spec = mock('metric_spec')
+    stats = mock('stats')
+    metric_id = mock('metric_id')
+    md1 = NewRelic::MetricData.new(spec, stats, metric_id)
+    assert((spec.hash ^ stats.hash) == md1.hash, "expected #{spec.hash ^ stats.hash} to equal #{md1.hash}")
+  end
+
+  def test_to_json_no_metric_id
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', ''), NewRelic::Agent::Stats.new, nil)
+    json = md.to_json
+    assert(json.include?('"Custom/test/method"'), "should include the metric spec in the json")
+    assert(json.include?('"metric_id":null}'), "should have a null metric_id")
+  end
+
+  def test_to_json_with_metric_id
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', ''), NewRelic::Agent::Stats.new, 12345)
+    assert_equal('{"metric_spec":null,"stats":{"total_exclusive_time":0.0,"min_call_time":0.0,"call_count":0,"sum_of_squares":0.0,"total_call_time":0.0,"max_call_time":0.0},"metric_id":12345}', md.to_json, "should not include the metric spec and should have a metric_id")
+  end
+
+  def test_to_s_with_metric_spec
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', ''), NewRelic::Agent::Stats.new, 12345)
+    assert_equal('Custom/test/method(): [ 0 calls 0.0000s]', md.to_s, "should not include the metric id and should include the metric spec")
+  end
+
+  def test_to_s_without_metric_spec
+    md = NewRelic::MetricData.new(nil, NewRelic::Agent::Stats.new, 12345)
+    assert_equal('12345: [ 0 calls 0.0000s]', md.to_s, "should include the metric id and not have a metric spec")
+  end
+
+  def test_to_collector_array_with_spec
+    stats = NewRelic::Agent::Stats.new
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', 'scope'),
+                                  stats, nil)
+    expected = [ {'name' => 'Custom/test/method', 'scope' => 'scope'},
+                 [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_spec_and_id
+    stats = NewRelic::Agent::Stats.new
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    md = NewRelic::MetricData.new(NewRelic::MetricSpec.new('Custom/test/method', 'scope'),
+                                  stats, 1234)
+    expected = [ 1234, [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_id
+    stats = NewRelic::Agent::Stats.new
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    md = NewRelic::MetricData.new(nil, stats, 1234)
+    expected = [ 1234, [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
+    assert_equal expected, md.to_collector_array
+  end
+
+  # Rationals in metric data? -- https://support.newrelic.com/tickets/28053
+  def test_to_collector_array_with_rationals
+    stats = NewRelic::Agent::Stats.new
+    stats.call_count = Rational(1, 1)
+    stats.total_call_time = Rational(2, 1)
+    stats.total_exclusive_time = Rational(3, 1)
+    stats.min_call_time = Rational(4, 1)
+    stats.max_call_time = Rational(5, 1)
+    stats.sum_of_squares = Rational(6, 1)
+
+    md = NewRelic::MetricData.new(nil, stats, 1234)
+    expected = [1234, [1, 2.0, 3.0, 4.0, 5.0, 6.0]]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_bad_values
+    stats = NewRelic::Agent::Stats.new
+    stats.call_count = nil
+    stats.total_call_time = "junk"
+    stats.total_exclusive_time = Object.new
+    stats.min_call_time = []
+    stats.max_call_time = {}
+    stats.sum_of_squares = Exception.new("Boo")
+
+    md = NewRelic::MetricData.new(nil, stats, 1234)
+    expected = [1234, [0, 0, 0, 0, 0, 0]]
+    assert_equal expected, md.to_collector_array
+  end
+end

data/test/new_relic/metric_parser/metric_parser_test.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..', 'test_helper'))
+class NewRelic::MetricParser::MetricParserTest < Test::Unit::TestCase
+  class ::AnApplicationClass
+  end
+
+  def test_metric_parser_does_not_instantiate_non_metric_parsing_classes
+    assert NewRelic::MetricParser::MetricParser.for_metric_named('AnApplicationClass/Foo/Bar').
+      is_a? NewRelic::MetricParser::MetricParser
+  end
+
+end

data/test/new_relic/metric_spec_test.rb

@@ -0,0 +1,95 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+class NewRelic::MetricSpecTest < Test::Unit::TestCase
+
+  def test_equal
+    spec1 = NewRelic::MetricSpec.new('Controller')
+    spec2 = NewRelic::MetricSpec.new('Controller', nil)
+
+    assert spec1.eql?(NewRelic::MetricSpec.new('Controller'))
+    assert spec2.eql?(NewRelic::MetricSpec.new('Controller', nil))
+    assert spec1.eql?(spec2)
+    assert !spec2.eql?(NewRelic::MetricSpec.new('Controller', '/dude'))
+  end
+
+  define_method(:'test_<=>') do
+    s1 = NewRelic::MetricSpec.new('ActiveRecord')
+    s2 = NewRelic::MetricSpec.new('Controller')
+    assert_equal [s1, s2].sort, [s1,s2]
+    assert_equal [s2, s1].sort, [s1,s2]
+
+    s1 = NewRelic::MetricSpec.new('Controller', nil)
+    s2 = NewRelic::MetricSpec.new('Controller', 'hap')
+    assert_equal [s2, s1].sort, [s1, s2]
+    assert_equal [s1, s2].sort, [s1, s2]
+
+    s1 = NewRelic::MetricSpec.new('Controller', 'hap')
+    s2 = NewRelic::MetricSpec.new('Controller', nil)
+    assert_equal [s2, s1].sort, [s2, s1]
+    assert_equal [s1, s2].sort, [s2, s1]
+
+    s1 = NewRelic::MetricSpec.new('Controller')
+    s2 = NewRelic::MetricSpec.new('Controller')
+    assert_equal [s2, s1].sort, [s2, s1] # unchanged due to no sort criteria
+    assert_equal [s1, s2].sort, [s1, s2] # unchanged due to no sort criteria
+
+    s1 = NewRelic::MetricSpec.new('Controller', nil)
+    s2 = NewRelic::MetricSpec.new('Controller', nil)
+    assert_equal [s2, s1].sort, [s2, s1] # unchanged due to no sort criteria
+    assert_equal [s1, s2].sort, [s1, s2] # unchanged due to no sort criteria
+  end
+
+  # test to make sure the MetricSpec class can serialize to json
+  def test_json
+    spec = NewRelic::MetricSpec.new("controller", "metric#find")
+
+    import = ::ActiveSupport::JSON.decode(spec.to_json)
+
+    compare_spec(spec, import)
+
+    stats = NewRelic::Agent::Stats.new
+
+    import = ::ActiveSupport::JSON.decode(stats.to_json)
+
+    compare_stat(stats, import)
+
+    metric_data = NewRelic::MetricData.new(spec, stats, 10)
+
+    import = ::ActiveSupport::JSON.decode(metric_data.to_json)
+
+    compare_metric_data(metric_data, import)
+  end
+
+  def test_truncate!
+    spec = NewRelic::MetricSpec.new('a', 'b')
+    spec.name = "a" * 300
+    spec.scope = "b" * 300
+    spec.truncate!
+    assert_equal("a" * 255, spec.name, "should have shortened the name")
+    assert_equal("b" * 255, spec.scope, "should have shortened the scope")
+  end
+
+  private
+
+  def compare_spec(spec, import)
+    assert_equal 2, import.length
+    assert_equal spec.name, import['name']
+    assert_equal spec.scope, import['scope']
+  end
+
+  def compare_stat(stats, import)
+    assert_equal 6, import.length
+    assert_equal stats.total_call_time, import['total_call_time']
+    assert_equal stats.max_call_time, import['max_call_time']
+    assert_equal stats.min_call_time, import['min_call_time']
+    assert_equal stats.sum_of_squares, import['sum_of_squares']
+    assert_equal stats.call_count, import['call_count']
+    assert_equal stats.total_exclusive_time, import['total_exclusive_time']
+  end
+
+  def compare_metric_data(metric_data, import)
+    assert_equal 3, import.length
+    assert_equal metric_data.metric_id, import['metric_id']
+    compare_spec(metric_data.metric_spec, import['metric_spec']) unless metric_data.metric_id
+    compare_stat(metric_data.stats, import['stats'])
+  end
+end