wd_newrelic_rpm 3.3.4.1

data/test/new_relic/data_serialization_test.rb

@@ -0,0 +1,208 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
+require 'new_relic/data_serialization'
+class NewRelic::DataSerializationTest < Test::Unit::TestCase
+
+  attr_reader :file, :path
+  
+  def setup
+    NewRelic::Control.instance['log_file_path'] = './log'
+    @path = NewRelic::Control.instance.log_path
+    @file = "#{path}/newrelic_agent_store.db"
+    Dir.mkdir(path) if !File.directory?(path)
+    FileUtils.rm_rf(@file)
+    FileUtils.rm_rf("#{@path}/newrelic_agent_store.pid")
+  end
+  
+  def teardown
+    # this gets set to true in some tests
+    NewRelic::Control.instance['disable_serialization'] = false
+    mocha_teardown
+  end
+  
+  def test_read_and_write_from_file_read_only
+    File.open(file, 'w') do |f|
+      f.write(Marshal.dump('a happy string'))
+    end
+    NewRelic::DataSerialization.read_and_write_to_file do |data|
+      assert_equal('a happy string', data, "should pull the dumped item from the file")
+      nil # must explicitly return nil or the return value will be dumped
+    end
+    assert_equal(0, File.size(file), "Should not leave any data in the file")
+  end
+  
+  def test_read_and_write_to_file_dumping_contents
+    expected_contents = Marshal.dump('a happy string')
+    NewRelic::DataSerialization.read_and_write_to_file do
+      'a happy string'
+    end
+    assert_equal(expected_contents, File.read(file), "should have dumped the contents")
+  end
+
+  def test_read_and_write_to_file_yields_old_data
+    expected_contents = 'a happy string'
+    File.open(file, 'w') do |f|
+      f.write(Marshal.dump(expected_contents))
+    end
+    contents = nil
+    NewRelic::DataSerialization.read_and_write_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_read_and_write_to_file_round_trip
+    old_data = nil
+    NewRelic::DataSerialization.read_and_write_to_file do |data|
+      old_data = data
+      'a' * 30
+    end
+    NewRelic::DataSerialization.read_and_write_to_file do |data|
+      assert_equal('a'*30, data, "should be the same after serialization")
+    end
+  end
+
+  def test_should_send_data_when_over_limit
+    NewRelic::DataSerialization.stubs(:max_size).returns(20)
+    NewRelic::DataSerialization.read_and_write_to_file do
+      "a" * 30
+    end
+    assert(NewRelic::DataSerialization.should_send_data?, 'Should be over limit')
+  end
+
+  def test_read_until_eoferror
+    File.open(file, 'w') do |f|
+      f.write("a" * 10_001)
+    end
+    value = ""
+    File.open(file,'r') do |f|
+      value << NewRelic::DataSerialization.instance_eval { read_until_eof_error(f) }
+    end
+    assert_equal('a' * 10_001, value, "should retrieve all the contents from the string and not raise EOFerrors")
+  end
+  
+  def test_write_contents_nonblockingly
+    File.open(file, 'w') do |f|
+      f.write("") # write nothing! NOTHING
+    end
+
+    File.open(file, 'w') do |f|
+      NewRelic::DataSerialization.instance_eval { write_contents_nonblockingly(f, 'a' * 10_001) }
+    end
+    value = File.read(file)
+    assert_equal('a' * 10_001, value, "should write a couple thousand 'a's to a file without exploding")
+  end
+
+  def test_should_send_data_disabled
+    NewRelic::Control.instance.disable_serialization = true
+    assert(NewRelic::DataSerialization.should_send_data?,
+           'should send data when disabled')
+  end
+
+  def test_should_send_data_under_limit
+    NewRelic::DataSerialization.expects(:max_size).returns(2000)
+    NewRelic::DataSerialization.read_and_write_to_file do |old_data|
+      "a" * 5
+    end
+    
+    assert(!NewRelic::DataSerialization.store_too_large?,
+           'Should be under the limit')
+  end
+
+  def test_should_handle_empty_spool_file
+    NewRelic::Control.instance.log.expects(:error).never
+    assert_nil NewRelic::DataSerialization.instance_eval { load('') }
+  end
+
+  def test_spool_file_location_respects_log_file_path_setting
+    NewRelic::Control.instance.expects(:log_path).returns('./tmp')
+    Dir.mkdir('./tmp') if !File.directory?('./tmp')
+    NewRelic::DataSerialization.read_and_write_to_file do |_|
+      'a' * 30
+    end
+    assert(File.exists?('./tmp/newrelic_agent_store.db'),
+           "Spool file not created at user specified location")
+  end
+
+  def test_age_file_location_respects_log_file_path_setting
+    NewRelic::Control.instance.expects(:log_path).returns('./tmp')
+    Dir.mkdir('./tmp') if !File.directory?('./tmp')
+    NewRelic::DataSerialization.update_last_sent!
+    assert(File.exists?('./tmp/newrelic_agent_store.pid'),
+           "Age file not created at user specified location")
+  end
+  
+  def test_pid_age_creates_pid_file_if_none_exists
+    assert(!File.exists?("#{@path}/newrelic_agent_store.pid"),
+           'pid file found, should not be there')
+    NewRelic::DataSerialization.update_last_sent!
+    assert(File.exists?("#{@path}/newrelic_agent_store.pid"),
+           'pid file not found, should be there')
+  end
+  
+  def test_should_not_create_files_if_serialization_disabled
+    NewRelic::Control.instance['disable_serialization'] = true
+    NewRelic::DataSerialization.should_send_data?
+    assert(!File.exists?("#{@path}/newrelic_agent_store.db"),
+           'db file created when serialization disabled')
+    assert(!File.exists?("#{@path}/newrelic_agent_store.pid"),
+           'pid file created when serialization disabled')
+  end
+  
+  def test_loading_does_not_seg_fault_if_gc_triggers
+    return if NewRelic::LanguageSupport.using_version?('1.8.6')
+    require 'timeout'
+    
+    Thread.abort_on_exception = true
+    rcv,snd = IO.pipe
+    
+    write = Thread.new do
+      obj = ('a'..'z').inject({}){|h,s|h[s.intern]=s*1024;h}
+      data = Marshal.dump(obj)
+      snd.write(data[0,data.size/2])
+      sleep(0.1)
+      snd.write(data[(data.size/2)..-1])
+      snd.close
+    end
+    
+    read = Thread.new do
+      lock = Mutex.new
+      lock.synchronize do
+        NewRelic::DataSerialization.class_eval { load(rcv) }
+      end
+    end
+
+    gc = Thread.new do
+      10.times do
+        GC.start
+      end
+    end
+
+    Timeout::timeout(5) do
+      write.join
+      read.join
+      gc.join
+    end
+    # should not seg fault
+  end
+
+  def test_dump_should_be_thread_safe
+    stats_hash = {}
+
+    2000.times do |i|
+      stats_hash[i.to_s] = NewRelic::StatsBase.new
+    end
+        
+    harvest = Thread.new do
+      NewRelic::DataSerialization.class_eval { dump(stats_hash) }
+    end
+    
+    app = Thread.new do
+      stats_hash["a"] = NewRelic::StatsBase.new
+    end
+    
+    assert_nothing_raised do
+      [app, harvest].each{|t| t.join}
+    end    
+  end
+end

data/test/new_relic/delayed_job_injection_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+
+class NewRelic::DelayedJobInstrumentationTest < Test::Unit::TestCase
+  def test_skip_logging_if_no_logger_found
+    Object.const_set('Delayed', Module.new) unless defined?(Delayed)
+    ::Delayed.const_set('Worker', Class.new) unless defined?(::Delayed::Worker)
+    
+    NewRelic::Agent.stubs(:logger).raises(NoMethodError,
+                                            'tempoarily not allowed')
+    NewRelic::Agent.stubs(:respond_to?).with(:logger).returns(false)
+    
+    assert DependencyDetection.detect!
+    
+    Object.class_eval { remove_const('Delayed') }
+  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 ::Passenger
+        const_set "AbstractServer", 0
+      end
+    end
+    e = NewRelic::LocalEnvironment.new
+    assert_equal :passenger, e.environment
+    assert_nil e.dispatcher_instance_id, "dispatcher instance id should be nil: #{e.dispatcher_instance_id}"
+
+    NewRelic::Control.instance.instance_eval do
+      @settings['app_name'] = 'myapp'
+    end
+
+    e = NewRelic::LocalEnvironment.new
+    assert_equal :passenger, e.environment
+    assert_nil e.dispatcher_instance_id
+
+    ::Passenger.class_eval { remove_const :AbstractServer }
+  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]|9\.\d)/, 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,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_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