dolores_rpm 3.2.0.2

data/test/new_relic/control/logging_methods_test.rb

@@ -0,0 +1,185 @@
+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
+  include NewRelic::Control::Configuration
+  def root; "."; end
+end
+
+class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
+  def setup
+    @base = BaseLoggingMethods.new
+    @base.settings['log_file_path'] = 'log/'
+    @base.settings['log_file_name'] = 'newrelic_agent.log'
+    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)
+    @base.stubs(:to_stdout)
+    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_existing_file
+    fake_logger = mock('logger')
+    Logger.expects(:new).with('logpath/logfilename').returns(fake_logger)
+    @base.expects(:log_path).returns('logpath').at_least_once
+    @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.settings['log_file_path'] = '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.settings['log_file_path'] = '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.settings['log_file_path'] = 'tmp/log_path_test'
+    assert !File.directory?(path) || FileUtils.rmdir(path)
+    @base.expects(:log!).with("Error creating log directory tmp/log_path_test, using standard out for logging.", :warn)
+    Dir.expects(:mkdir).with(path).raises('cannot make directory bro!').twice # once for the relative directory, once for the directory relative to Rails.root
+    assert_nil @base.log_path
+    assert !File.directory?(path)
+    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev    
+  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
+
+  def test_log_to_stdout_when_log_file_path_set_to_STDOUT
+    @base.stubs(:fetch).returns('whatever')
+    @base.expects(:fetch).with('log_file_path', 'log').returns('STDOUT')
+    Dir.expects(:mkdir).never
+    @base.setup_log
+    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev    
+  end
+
+  def test_logs_to_stdout_include_newrelic_prefix
+    @base.stubs(:fetch).returns('whatever')
+    @base.expects(:fetch).with('log_file_path', 'log').returns('STDOUT')
+    STDOUT.expects(:write).with(regexp_matches(/\*\* \[NewRelic\].*whee/))
+    @base.setup_log
+    @base.log.info('whee')
+  end
+
+  def test_set_stdout_destination_from_NEW_RELIC_LOG_env_var
+    @base.stubs(:fetch).returns('whatever')
+    ENV['NEW_RELIC_LOG'] = 'stdout'
+    Dir.expects(:mkdir).never
+    @base.setup_log
+    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev
+    ENV['NEW_RELIC_LOG'] = nil
+  end
+
+  def test_set_file_destination_from_NEW_RELIC_LOG_env_var
+    @base.stubs(:fetch).returns('whatever')
+    ENV['NEW_RELIC_LOG'] = 'log/file.log'
+    @base.setup_log
+    assert_equal 'log', File.basename(@base.log_path)
+    assert_equal 'file.log', @base.log_file_name
+    ENV['NEW_RELIC_LOG'] = nil    
+  end
+end

data/test/new_relic/control_test.rb

@@ -0,0 +1,254 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
+class NewRelic::ControlTest < Test::Unit::TestCase
+
+  attr_reader :control
+
+  def setup
+    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
+    @control =  NewRelic::Control.instance
+    raise 'oh geez, wrong class' unless NewRelic::Control.instance.is_a?(::NewRelic::Control::Frameworks::Test)
+  end
+
+  def shutdown
+    NewRelic::Agent.shutdown
+  end
+
+  def test_cert_file_path
+    assert @control.cert_file_path
+    assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @control.cert_file_path
+  end
+  
+  # This test does not actually use the ruby agent in any way - it's
+  # testing that the CA file we ship actually validates our server's
+  # certificate. It's used for customers who enable verify_certificate
+  def test_cert_file
+    require 'socket'
+    require 'openssl'
+
+    s   = TCPSocket.new 'collector.newrelic.com', 443
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.ca_file = @control.cert_file_path
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    s   = OpenSSL::SSL::SSLSocket.new s, ctx
+    s.connect
+    # should not raise an error
+  end
+  
+  # see above, but for staging, as well. This allows us to test new
+  # certificates in a non-customer-facing place before setting them
+  # live.
+  def test_staging_cert_file
+    require 'socket'
+    require 'openssl'
+
+    s   = TCPSocket.new 'staging-collector.newrelic.com', 443
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.ca_file = @control.cert_file_path
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    s   = OpenSSL::SSL::SSLSocket.new s, ctx
+    s.connect
+    # should not raise an error
+  end
+
+  def test_monitor_mode
+    assert ! @control.monitor_mode?
+    @control.settings.delete 'enabled'
+    @control.settings.delete 'monitor_mode'
+    assert !@control.monitor_mode?
+    @control['enabled'] = false
+    assert ! @control.monitor_mode?
+    @control['enabled'] = true
+    assert @control.monitor_mode?
+    @control['monitor_mode'] = nil
+    assert !@control.monitor_mode?
+    @control['monitor_mode'] = false
+    assert !@control.monitor_mode?
+    @control['monitor_mode'] = true
+    assert @control.monitor_mode?
+  ensure
+    @control['enabled'] = false
+    @control['monitor_mode'] = false
+  end
+
+  def test_test_config
+    if defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
+      assert_equal :rails3, control.app
+    elsif defined?(Rails)
+      assert_equal :rails, control.app
+    else
+      assert_equal :test, control.app
+    end
+    assert_equal :test, control.framework
+    assert_match /test/i, control.dispatcher_instance_id
+    assert("" == control.dispatcher.to_s, "Expected dispatcher to be empty, but was #{control.dispatcher.to_s}")
+    assert !control['enabled']
+    assert_equal false, control['monitor_mode']
+    control.local_env
+  end
+
+  def test_root
+    assert File.directory?(NewRelic::Control.newrelic_root), NewRelic::Control.newrelic_root
+    if defined?(Rails)
+      assert File.directory?(File.join(NewRelic::Control.newrelic_root, "lib")), NewRelic::Control.newrelic_root +  "/lib"
+    end
+  end
+
+  def test_info
+    props = NewRelic::Control.instance.local_env.snapshot
+    if defined?(Rails)
+      assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last, props.inspect
+    end
+  end
+
+  def test_resolve_ip
+    assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
+    # This will fail if you don't have a valid, accessible, DNS server
+    assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
+  end
+
+  class FakeResolv
+    def self.getaddress(host)
+      raise 'deliberately broken'
+    end
+  end
+
+  def test_resolve_ip_with_broken_dns
+    # Here be dragons: disable the ruby DNS lookup methods we use so
+    # that it will actually fail to resolve.
+    old_resolv = Resolv
+    old_ipsocket = IPSocket
+    Object.instance_eval { remove_const :Resolv}
+    Object.instance_eval {remove_const:'IPSocket' }
+    assert_equal(nil, control.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+
+    Object.instance_eval {const_set('Resolv', old_resolv); const_set('IPSocket', old_ipsocket)}
+    # these are here to make sure that the constant tomfoolery above
+    # has not broket the system unduly
+    assert_equal old_resolv, Resolv
+    assert_equal old_ipsocket, IPSocket
+  end
+
+  def test_config_yaml_erb
+    assert_equal 'heyheyhey', control['erb_value']
+    assert_equal '', control['message']
+    assert_equal '', control['license_key']
+  end
+
+  def test_appnames
+    assert_equal %w[a b c], NewRelic::Control.instance.app_names
+  end
+
+  def test_config_booleans
+    assert_equal control['tval'], true
+    assert_equal control['fval'], false
+    assert_nil control['not_in_yaml_val']
+    assert_equal control['yval'], true
+    assert_equal control['sval'], 'sure'
+  end
+
+  def test_config_apdex
+    assert_equal 1.1, control.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_log_file_name
+    NewRelic::Control.instance.setup_log
+    assert_match /newrelic_agent.log$/, control.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__default
+    forced_start :transaction_tracer => { :transaction_threshold => nil}
+    assert_nil control['transaction_tracer']['transaction_threshold']
+    assert_equal 2.0, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+  end
+
+  def test_transaction_threshold__override
+    forced_start :transaction_tracer => { :transaction_threshold => 1}
+    assert_equal 1, control['transaction_tracer']['transaction_threshold']
+    assert_equal 1, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+  end
+
+  def test_transaction_tracer_disabled
+    forced_start(:transaction_tracer => { :enabled => false },
+                 :developer_mode => false, :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_transaction_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
+           'transaction tracer enabled when config calls for disabled')
+    
+    @control['developer_mode'] = true
+    @control['monitor_mode'] = false
+  end
+  
+  def test_sql_tracer_disabled
+    forced_start(:slow_sql => { :enabled => false }, :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql tracer enabled when config calls for disabled')
+    
+    @control['monitor_mode'] = false
+  end
+  
+  def test_sql_tracer_disabled_with_record_sql_false
+    forced_start(:slow_sql => { :enabled => true, :record_sql => 'off' })
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql tracer enabled when config calls for disabled')
+  end
+
+  def test_sql_tracer_disabled_when_tt_disabled
+    forced_start(:transaction_tracer => { :enabled => false },
+                 :slow_sql => { :enabled => true },
+                 :developer_mode => false, :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql enabled when transaction tracer disabled')
+    
+    @control['developer_mode'] = true
+    @control['monitor_mode'] = false    
+  end
+
+  def test_sql_tracer_disabled_when_tt_disabled_by_server
+    forced_start(:slow_sql => { :enabled => true },
+                 :transaction_tracer => { :enabled => true },
+                 :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    NewRelic::Agent::Agent.instance.finish_setup('collect_traces' => false)    
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql enabled when tracing disabled by server')
+    
+    @control['monitor_mode'] = false        
+  end
+
+  def test_merging_options
+    NewRelic::Control.send :public, :merge_options
+    @control.merge_options :api_port => 66, :transaction_tracer => { :explain_threshold => 2.0 }
+    assert_equal 66, NewRelic::Control.instance['api_port']
+    assert_equal 2.0, NewRelic::Control.instance['transaction_tracer']['explain_threshold']
+    assert_equal 'raw', NewRelic::Control.instance['transaction_tracer']['record_sql']
+  end
+
+  private
+
+  def forced_start overrides = {}
+    NewRelic::Agent.manual_start overrides
+    # This is to force the agent to start again.
+    NewRelic::Agent.instance.stubs(:started?).returns(nil)
+    NewRelic::Agent.instance.start
+  end
+end

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_bad_paths
+    NewRelic::Control.instance.stubs(:log_path).returns("/bad/path")
+    assert NewRelic::DataSerialization.should_send_data?
+    NewRelic::DataSerialization.read_and_write_to_file do
+      'a happy string'
+    end
+    assert !File.exists?(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')
+    assert(!NewRelic::DataSerialization.pid_too_old?,
+           "new pid should not be too old")
+    assert(File.exists?("#{@path}/newrelic_agent_store.pid"),
+           'pid file not found, should be there')
+  end
+
+  def test_loading_does_not_seg_fault_if_gc_triggers
+    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