newrelic_rpm 3.0.1 → 3.1.0.beta1

data/test/new_relic/control/logging_methods_test.rb

@@ -0,0 +1,157 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/control/logging_methods'
+require 'fileutils'
+
+class BaseLoggingMethods
+  # stub class to enable testing of the module
+  include NewRelic::Control::LoggingMethods
+end
+
+class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
+  def setup
+    @base = BaseLoggingMethods.new
+    super
+  end
+
+  def test_log_basic
+    mock_logger = mock('logger')
+    @base.instance_eval { @log = mock_logger }
+    assert_equal mock_logger, @base.log
+  end
+
+  def test_log_no_log
+    log = @base.log
+    assert_equal Logger, log.class
+    assert_equal Logger::INFO, log.level
+    # have to root around in the logger for the logdev
+    assert_equal STDOUT, log.instance_eval { @logdev }.dev
+  end
+
+  def test_logbang_basic
+    @base.expects(:should_log?).returns(true)
+    @base.expects(:to_stdout).with('whee')
+    @base.instance_eval { @log = nil }
+    @base.log!('whee')
+  end
+
+  def test_logbang_should_not_log
+    @base.expects(:should_log?).returns(false)
+    assert_equal nil, @base.log!('whee')
+  end
+
+  def test_logbang_with_log
+    @base.expects(:should_log?).returns(true)
+    @base.expects(:to_stdout).with('whee')
+    fake_logger = mock('log')
+    fake_logger.expects(:send).with(:info, 'whee')
+    @base.instance_eval { @log = fake_logger }
+    @base.log!('whee')
+  end
+
+  def test_should_log_no_settings
+    @base.instance_eval { @settings = nil }
+    assert !@base.should_log?
+  end
+
+  def test_should_log_agent_disabled
+    @base.instance_eval { @settings = true }
+    @base.expects(:agent_enabled?).returns(false)
+    assert !@base.should_log?
+  end
+
+  def test_should_log_agent_enabled
+    @base.instance_eval { @settings = true }
+    @base.expects(:agent_enabled?).returns(true)
+    assert @base.should_log?
+  end
+
+  def test_set_log_level_base
+    fake_logger = mock('logger')
+    # bad configuration
+    @base.expects(:fetch).with('log_level', 'info').returns('whee')
+    fake_logger.expects(:level=).with(Logger::INFO)
+    assert_equal fake_logger, @base.set_log_level!(fake_logger)
+  end
+
+  def test_set_log_level_with_each_level
+    fake_logger = mock('logger')
+    %w[debug info warn error fatal].each do |level|
+      @base.expects(:fetch).with('log_level', 'info').returns(level)
+      fake_logger.expects(:level=).with(Logger.const_get(level.upcase))
+      assert_equal fake_logger, @base.set_log_level!(fake_logger)
+    end
+  end
+
+  def test_set_log_format
+    fake_logger = Object.new
+    assert !fake_logger.respond_to?(:format_message)
+    assert_equal fake_logger, @base.set_log_format!(fake_logger)
+    assert fake_logger.respond_to?(:format_message)
+  end
+
+  def test_setup_log_file_not_exist
+    @base.expects(:log_path).returns('logpath')
+    @base.expects(:log_file_name).returns('logfilename')
+    fake_logger = mock('logger')
+    @base.expects(:log).returns(fake_logger)
+    @base.setup_log
+    assert_equal nil, @base.instance_eval { @log }
+    assert_equal 'logpath/logfilename', @base.instance_eval { @log_file }
+  end
+
+  def test_setup_log_existing_file
+    fake_logger = mock('logger')
+    Logger.expects(:new).with('logpath/logfilename').returns(fake_logger)
+    @base.expects(:log_path).returns('logpath')
+    @base.expects(:log_file_name).returns('logfilename')
+    @base.expects(:set_log_format!).with(fake_logger)
+    @base.expects(:set_log_level!).with(fake_logger)
+    assert_equal fake_logger, @base.setup_log
+    assert_equal fake_logger, @base.instance_eval { @log }
+    assert_equal 'logpath/logfilename', @base.instance_eval { @log_file }
+  end
+
+  def test_to_stdout
+    STDOUT.expects(:puts).with('** [NewRelic] whee')
+    @base.to_stdout('whee')
+  end
+
+  def test_log_path_exists
+    @base.instance_eval { @log_path = 'logpath' }
+    assert_equal 'logpath', @base.log_path
+  end
+
+  def test_log_path_path_exists
+    @base.instance_eval { @log_path = nil }
+    @base.expects(:fetch).with('log_file_path', 'log/').returns('log/')
+    assert File.directory?('log/')
+    assert_equal File.expand_path('log/'), @base.log_path
+  end
+
+  def test_log_path_path_created
+    path = File.expand_path('tmp/log_path_test')
+    @base.instance_eval { @log_path = nil }
+    @base.expects(:fetch).with('log_file_path', 'log/').returns('tmp/log_path_test')
+    assert !File.directory?(path) || FileUtils.rmdir(path)
+    @base.expects(:log!).never
+    assert_equal path, @base.log_path
+    assert File.directory?(path)
+  end
+
+  def test_log_path_path_unable_to_create
+    path = File.expand_path('tmp/log_path_test')
+    @base.instance_eval { @log_path = nil }
+    @base.expects(:fetch).with('log_file_path', 'log/').returns('tmp/log_path_test')
+    assert !File.directory?(path) || FileUtils.rmdir(path)
+    @base.expects(:log!).with("Error creating New Relic log directory '#{path}'", :error)
+    Dir.expects(:mkdir).with(path).raises('cannot make directory bro!')
+    assert_equal path, @base.log_path
+    assert !File.directory?(path)
+  end
+
+  def test_log_file_name
+    @base.expects(:fetch).with('log_file_name', 'newrelic_agent.log').returns('log_file_name')
+    assert_equal 'log_file_name', @base.log_file_name
+  end
+end
+

data/test/new_relic/control_test.rb

@@ -58,7 +58,7 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     end
     assert_equal :test, c.framework
     assert_match /test/i, c.dispatcher_instance_id
-    assert("" == c.dispatcher.to_s)
+    assert("" == c.dispatcher.to_s, "Expected dispatcher to be empty, but was #{c.dispatcher.to_s}")
     assert !c['enabled']
     assert_equal false, c['monitor_mode']
     c.local_env
@@ -129,20 +129,20 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   def test_config_apdex
     assert_equal 1.1, c.apdex_t
   end
-  def test_transaction_threshold
-    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
-    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-  end
+#  def test_transaction_threshold
+#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
+#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+#  end
   def test_log_file_name
     NewRelic::Control.instance.setup_log
     assert_match /newrelic_agent.log$/, c.instance_variable_get('@log_file')
   end
 
-  def test_transaction_threshold__apdex
-    forced_start
-    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
-    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
-  end
+#  def test_transaction_threshold__apdex
+#    forced_start
+#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
+#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+#  end
 
   def test_transaction_threshold__default
 

data/test/new_relic/data_serialization_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+require 'new_relic/data_serialization'
+class NewRelic::DataSerializationTest < Test::Unit::TestCase
+  def test_load_from_file
+    file = './log/newrelic_agent_store.db'
+    File.open(file, 'w') do |f|
+      f.write(Marshal.dump('a happy string'))
+    end
+    assert_equal('a happy string', NewRelic::DataSerialization.load_from_file, "should pull the dumped item from the file")
+    assert_equal(0, File.size(file), "Should not leave any data in the file")
+  end
+
+  def test_dump_to_file
+    file = './log/newrelic_agent_store.db'
+    expected_contents = Marshal.dump('a happy string')
+    NewRelic::DataSerialization.dump_to_file do
+      'a happy string'
+    end
+    assert_equal(expected_contents, File.read(file), "should have dumped the contents")
+  end
+
+  def test_dump_to_file_yields_old_data
+    file = './log/newrelic_agent_store.db'
+    expected_contents = 'a happy string'
+    File.open(file, 'w') do |f|
+      f.write(Marshal.dump(expected_contents))
+    end
+    contents = nil
+    NewRelic::DataSerialization.dump_to_file do |old_data|
+      contents = old_data
+      'a happy string'
+    end
+    assert_equal(contents, expected_contents, "should have dumped the contents")
+  end
+
+  def test_round_trip
+    NewRelic::DataSerialization.dump_to_file do
+      'a' * 30
+    end
+    assert_equal('a'*30, NewRelic::DataSerialization.load_from_file, "should be the same after serialization")
+  end
+
+  def test_should_send_data
+    NewRelic::DataSerialization.expects(:max_size).returns(20)
+    NewRelic::DataSerialization.dump_to_file do
+      "a" * 30
+    end
+    assert(NewRelic::DataSerialization.should_send_data?, 'Should be over limit')
+  end
+end

data/test/new_relic/local_environment_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
 class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
 
-  def teardown
+  def self.teardown
     # To remove mock server instances from ObjectSpace
     ObjectSpace.garbage_collect
     super
@@ -13,18 +13,18 @@ class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
   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_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

data/test/new_relic/metric_data_test.rb

@@ -0,0 +1,125 @@
+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::MethodTraceStats.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::MethodTraceStats.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::MethodTraceStats.new, 12345)
+    assert_equal('Custom/test/method(): [01/01/70 12:00AM UTC, 0.000s;  0 calls    0s]', 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::MethodTraceStats.new, 12345)
+    assert_equal('12345: [01/01/70 12:00AM UTC, 0.000s;  0 calls    0s]', md.to_s, "should include the metric id and not have a metric spec")
+  end
+end

data/test/new_relic/metric_spec_test.rb

@@ -59,6 +59,14 @@ class NewRelic::MetricSpecTest < Test::Unit::TestCase
     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
 

data/test/new_relic/transaction_analysis/segment_summary_test.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..','test_helper'))
+require 'new_relic/transaction_analysis/segment_summary'
+class NewRelic::TransactionAnalysis::SegmentSummaryTest < Test::Unit::TestCase
+
+  def setup
+    @sample = mock('sample')
+    @ss = NewRelic::TransactionAnalysis::SegmentSummary.new('Controller/foo', @sample)
+  end
+
+  # these are mostly stub tests just making sure that the API doesn't
+  # change if anyone ever needs to modify it.
+
+  def test_insert
+    segment = mock('segment')
+    segment.expects(:metric_name).returns('Controller/foo')
+    segment.expects(:duration).returns(0.1)
+    segment.expects(:exclusive_duration).returns(0.1)
+    @ss << segment
+    assert_equal 0.1, @ss.total_time
+    assert_equal 0.1, @ss.exclusive_time
+    assert_equal 1, @ss.call_count
+  end
+
+  def test_insert_error
+    segment = mock('segment')
+    segment.expects(:metric_name).returns('Controller/bar').twice
+    assert_raise(ArgumentError) do
+      @ss << segment
+    end
+  end
+
+  def test_average_time
+    @ss.total_time = 0.1
+    @ss.call_count = 2
+    assert_equal 0.05, @ss.average_time
+  end
+
+  def test_average_exclusive_time
+    @ss.exclusive_time = 0.1
+    @ss.call_count = 2
+    assert_equal 0.05, @ss.average_exclusive_time
+  end
+
+  def test_exclusive_time_percentage_nil
+    @ss.exclusive_time = nil
+    assert_equal 0, @ss.exclusive_time_percentage
+  end
+
+  def test_exclusive_time_percentage
+    @ss.exclusive_time = 0.05
+    @sample.expects(:duration).returns(0.1).times(3)
+    assert_equal 0.5, @ss.exclusive_time_percentage
+  end
+
+  def test_total_time_percentage_nil
+    @ss.total_time = nil
+    assert_equal 0, @ss.total_time_percentage
+  end
+
+  def test_total_time_percentage
+    @ss.total_time = 0.05
+    @sample.expects(:duration).returns(0.1).times(3)
+    assert_equal 0.5, @ss.total_time_percentage
+  end
+
+  def test_ui_name_default
+    @ss.metric_name = 'Remainder'
+    assert_equal 'Remainder', @ss.ui_name
+  end
+
+  def test_ui_name_lookup
+    mocked_object = mock('metric parser obj')
+    mocked_object.expects(:developer_name).returns('Developer Name')
+    NewRelic::MetricParser::MetricParser.expects(:parse).with('Controller/foo').returns(mocked_object)
+    assert_equal 'Developer Name', @ss.ui_name
+  end
+end