newrelic_rpm 3.5.6.42.beta → 3.5.6.46.beta

data/Rakefile

@@ -47,7 +47,12 @@ desc 'Record build number and stage'
 task :record_build, [ :build_number, :stage ] do |t, args|
   build_string = args.build_number
   build_string << ".#{args.stage}" if args.stage
+
+  gitsha = File.exists?(".git") ? `git rev-parse HEAD` : "Unknown"
+  gitsha.chomp!
+
   File.open("lib/new_relic/build.rb", "w") do |f|
+    f.write("# GITSHA: #{gitsha}\n")
     f.write("module NewRelic; module VERSION; BUILD='#{build_string}'; end; end\n")
   end
 end

data/lib/new_relic/agent/busy_calculator.rb

@@ -31,10 +31,15 @@ module NewRelic
       # instance variable accumulator. this is harvested when we send
       # data to the server
       def dispatcher_finish(end_time = nil)
+        # If #dispatcher_start hasn't been called at least once, abort early
+        return unless Thread.current[:busy_entries]
+
         end_time ||= time_now
         callers = Thread.current[:busy_entries] -= 1
+
         # Ignore nested calls
         return if callers > 0
+
         @lock.synchronize do
           if @entrypoint_stack.empty?
             ::NewRelic::Agent.logger.warn("Stack underflow tracking dispatcher entry and exit!\n  #{caller.join("  \n")}")

data/lib/new_relic/agent/worker_loop.rb

@@ -12,7 +12,7 @@ module NewRelic
         @should_run = true
         @next_invocation_time = Time.now
         @period = 60.0
-        @deadline = Time.now + opts[:duration] if opts[:duration]
+        @duration = opts[:duration] if opts[:duration]
         @limit = opts[:limit] if opts[:limit]
         @iterations = 0
       end
@@ -26,6 +26,7 @@ module NewRelic
       # call periods.  The caller is responsible for creating the thread
       # that runs this worker loop.  This will run the task immediately.
       def run(period=nil, &block)
+        @deadline = Time.now + @duration if @duration
         @period = period if period
         @next_invocation_time = (Time.now + @period)
         @task = block

data/lib/new_relic/control/instance_methods.rb

@@ -93,7 +93,7 @@ module NewRelic
       end
 
       def settings
-        NewRelic::Agent.config.reported_config
+        NewRelic::Agent.config.to_collector_hash
       end
 
       def dispatcher

data/lib/new_relic/version.rb

@@ -11,7 +11,7 @@ module NewRelic
     TINY  = 6
 
     begin
-      require 'new_relic/build'
+      require File.join(File.dirname(__FILE__), 'build')
     rescue LoadError => e
       BUILD = nil
     end

data/newrelic_rpm.gemspec

@@ -27,7 +27,12 @@ EOS
     "GUIDELINES_FOR_CONTRIBUTING.md",
     "newrelic.yml"
   ]
-  s.files = `git ls-files`.split + ['lib/new_relic/build.rb']
+
+  file_list = `git ls-files`.split
+  build_file_path = 'lib/new_relic/build.rb'
+  file_list << build_file_path if File.exist?(build_file_path)
+  s.files = file_list
+
   s.homepage = "http://www.github.com/newrelic/rpm"
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "New Relic Ruby Agent"]
   s.require_paths = ["lib"]

data/test/multiverse/suites/active_record/Envfile

@@ -2,8 +2,8 @@ gemfile <<-RB
   if RUBY_VERSION == '1.8.6'
     gem 'activerecord', '2.3.14'
   elsif RUBY_PLATFORM == 'java'
+    gem 'activerecord-jdbcsqlite3-adapter', '1.2.2.1'
     gem 'jdbc-sqlite3'
-    gem 'activerecord-jdbcsqlite3-adapter'
     gem 'activerecord'
   else
     gem 'activerecord'

data/test/multiverse/suites/active_record/ar_method_aliasing.rb

@@ -13,7 +13,7 @@ class InstrumentActiveRecordMethods < Test::Unit::TestCase
   if RUBY_VERSION >= '1.8.7'
     if RUBY_PLATFORM == 'java'
       require 'jdbc/sqlite3'
-      @@adapter = 'jdbcsqlite3'
+      @@adapter = 'sqlite3'
     else
       require 'sqlite3'
       @@adapter = 'sqlite3'

data/test/multiverse/suites/agent_only/service_timeout_test.rb

@@ -1,8 +1,11 @@
 require 'socket'
 
 class ServiceTimeoutTest < Test::Unit::TestCase
+
+  PORT = 10_000 + ($$ % 10_000)
+
   def setup
-    hk = TCPServer.new('127.0.0.1',8081)
+    hk = TCPServer.new('127.0.0.1',PORT)
 
     Thread.new {
       client = hk.accept
@@ -14,8 +17,8 @@ class ServiceTimeoutTest < Test::Unit::TestCase
   end
 
   def test_service_timeout
-    server = NewRelic::Control::Server.new('localhost', 8081,'127.0.0.1')  
-    NewRelic::Agent.config.apply_config(:timeout => 2)
+    server = NewRelic::Control::Server.new('localhost',PORT,'127.0.0.1')
+    NewRelic::Agent.config.apply_config(:timeout => 0.1)
 
     service = NewRelic::Agent::NewRelicService.new('deadbeef', server)	
 

data/test/multiverse/suites/agent_only/start_up_test.rb

@@ -7,8 +7,15 @@ class StartUpTest < Test::Unit::TestCase
     cmd = "bundle exec ruby -e '#{ruby}'"
 
     sin, sout, serr = Open3.popen3(cmd)
+    output = sout.read + serr.read
 
-    jruby_noise = "JRuby limited openssl loaded. http://jruby.org/openssl\ngem install jruby-openssl for full support.\n"
-    assert_equal '', (sout.read + serr.read).sub(jruby_noise, '')
+    jruby_noise = [
+      "JRuby limited openssl loaded. http://jruby.org/openssl\n",
+      "gem install jruby-openssl for full support.\n",
+      /Exception\: java\.lang.*\n/]
+
+    jruby_noise.each {|noise| output.gsub!(noise, "")}
+
+    assert_equal '', output
   end
 end

data/test/multiverse/suites/rails/gc_instrumentation_test.rb

@@ -1,5 +1,9 @@
 require './app'
 
+# GC instrumentation only works with REE or 1.9.x
+if (defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION =~ /Enterprise/) ||
+    RUBY_VERSION >= '1.9.2'
+
 class GcController < ApplicationController
   include Rails.application.routes.url_helpers
   def gc_action
@@ -44,13 +48,13 @@ class GCRailsInstrumentationTest < ActionController::TestCase
     assert_in_delta(assigns[:duration],
                     NewRelic::Agent.agent.stats_engine \
                       .get_stats('GC/cumulative') \
-                      .total_call_time, 0.1,
+                      .total_call_time, 0.2,
                     'problem with unscoped GC metric')
     assert_in_delta(assigns[:duration],
                     NewRelic::Agent.agent.stats_engine \
                       .get_stats('GC/cumulative', true, false,
-                                 'Controller/test/gc_action') \
-                      .total_call_time, 0.1,
+                                 'Controller/gc/gc_action') \
+                      .total_call_time, 0.2,
                     'problem with scoped GC metric')
   end
 
@@ -58,7 +62,7 @@ class GCRailsInstrumentationTest < ActionController::TestCase
     get :gc_action
 
     trace = NewRelic::Agent.instance.transaction_sampler.last_sample
-    assert_in_delta(assigns[:duration], trace.params[:custom_params][:gc_time], 0.5)
+    assert_in_delta(assigns[:duration], trace.params[:custom_params][:gc_time], 0.2)
   end
 
   def enable_gc_stats
@@ -69,3 +73,5 @@ class GCRailsInstrumentationTest < ActionController::TestCase
     end
   end
 end
+
+end

data/test/multiverse/suites/resque/Envfile

@@ -11,11 +11,12 @@ gemfile <<-RB
 RB
 
 before_suite do
-  system('echo "daemonize yes" | redis-server -')
+  ENV["NEWRELIC_MULTIVERSE_REDIS_PORT"] = (20_000 + ($$ % 10_000)).to_s
+  system("echo 'port #{ENV["NEWRELIC_MULTIVERSE_REDIS_PORT"]}' | redis-server - > /dev/null &")
 end
 
 after_suite do
-  system('redis-cli shutdown')
+  system("redis-cli -p #{ENV["NEWRELIC_MULTIVERSE_REDIS_PORT"]} shutdown")
 end
 
 execute_mode 'spawn'

data/test/multiverse/suites/resque/instrumentation_test.rb

@@ -6,12 +6,14 @@ require 'logger'
 require 'newrelic_rpm'
 require 'fake_collector'
 
+REDIS_PORT = ENV["NEWRELIC_MULTIVERSE_REDIS_PORT"]
+
 class JobForTesting
   @queue = :resque_test
 
   def self.perform(key, val, sleep_duration=0)
     sleep sleep_duration
-    Redis.new.set(key, val)
+    Redis.new(:port => REDIS_PORT).set(key, val)
   end
 end
 
@@ -19,7 +21,8 @@ class ResqueTest < Test::Unit::TestCase
   JOB_COUNT = 5
 
   def setup
-    @redis = Redis.new
+    @redis = Redis.new(:port => REDIS_PORT)
+    Resque.redis = @redis
 
     $collector ||= NewRelic::FakeCollector.new
     $collector.reset
@@ -33,11 +36,24 @@ class ResqueTest < Test::Unit::TestCase
     Thread.new do
       worker.work
     end.abort_on_exception = true
-    sleep 1 # give the worker some time to process
+
+    wait_for_jobs
     worker.shutdown
 
     NewRelic::Agent.shutdown
-    sleep 0.5 # give the agent some time to report after shutdown
+  end
+
+  def wait_for_jobs
+    # JRuby barfs in the timeout on trying to read from Redis.
+    time_for_jobs = 2
+    if defined?(JRuby)
+      sleep time_for_jobs
+    else
+      # Give a little time to complete, get out early if we're done....
+      Timeout::timeout(time_for_jobs) do
+        until Resque.info[:pending] == 0; end
+      end
+    end
   end
 
   def teardown
@@ -59,15 +75,18 @@ class ResqueTest < Test::Unit::TestCase
                  "wrong number of metric_data posts in #{$collector.agent_data.inspect}")
   end
 
+
+  METRIC_VALUES_POSITION = 3
+
   def test_agent_posts_correct_call_count
     test_metric = 'OtherTransaction/ResqueJob/all'
-    metric_data = $collector.agent_data.find{|x| x.action == 'metric_data'}
+    metric_data = $collector.calls_for('metric_data').first
 
-    metric_names = metric_data.body[3].map{|m| m[0]['name']}
+    metric_names = metric_data[METRIC_VALUES_POSITION].map{|m| m[0]['name']}
     assert(metric_names.include?(test_metric),
            "#{metric_names.inspect} should include '#{test_metric}'")
 
-    call_count = metric_data.body[3].find{|m| m[0]['name'] == test_metric}[1][0]
+    call_count = metric_data[METRIC_VALUES_POSITION].find{|m| m[0]['name'] == test_metric}[1][0]
     assert_equal JOB_COUNT, call_count
   end
 end

data/test/new_relic/agent/busy_calculator_test.rb

@@ -85,4 +85,12 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
       assert_equal 0, @instance_busy.call_count
     end
   end
+
+  def test_finishing_without_starting_doesnt_raise
+    Thread.current[:busy_entries] = nil
+    assert_nothing_raised do
+      NewRelic::Agent::BusyCalculator.dispatcher_finish
+    end
+  end
+
 end

data/test/new_relic/agent/worker_loop_test.rb

@@ -18,6 +18,11 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
 
   def test_with_duration
     worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 0.1)
+
+    # Advance in small increments vs our period so time will pass over the
+    # nasty multiple calls to Time.now that WorkerLoop makes
+    Time.stubs(:now).returns(*ticks(0, 0.12, 0.005))
+
     count = 0
     worker_loop.run(0.04) do
       count += 1
@@ -26,6 +31,19 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     assert_equal 2, count
   end
 
+  def test_duration_clock_starts_with_run
+    # Purposefully testing time, but shouldn't be particularly fragile
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 0.01)
+    sleep 0.02
+
+    called = false
+    worker_loop.run(0.001) do
+      called = true
+    end
+
+    assert(called, "Didn't run the loop even once")
+  end
+
   def test_loop_limit
     worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 2)
     iterations = 0
@@ -33,21 +51,6 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     assert_equal 2, iterations
   end
 
-  def test_density
-    # This shows how the tasks stay aligned with the period and don't drift.
-    count = 0
-    start = Time.now
-    @worker_loop.run(0.03) do
-      count +=1
-      if count == 3
-        @worker_loop.stop
-        next
-      end
-    end
-    elapsed = Time.now - start
-    assert_in_delta 0.09, elapsed, 0.03
-  end
-
   def test_task_error__standard
     expects_logging(:error, any_parameters)
     # This loop task will run twice
@@ -78,4 +81,8 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
       raise NewRelic::Agent::ServerError, "Runtime Error Test"
     end
   end
+
+  def ticks(start, finish, step)
+    (start..finish).step(step).to_a
+  end
 end

data/test/new_relic/control_test.rb

@@ -67,6 +67,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     control.local_env
   end
 
+  def test_settings_accessor
+    assert_not_nil control.settings
+  end
+
   def test_root
     assert File.directory?(NewRelic::Control.newrelic_root), NewRelic::Control.newrelic_root
     if defined?(Rails)

data/test/new_relic/fake_collector.rb

@@ -82,15 +82,29 @@ module NewRelic
       FakeCollector.determine_port
     end
 
+    @seen_port_failure = false
+
     def run(port=nil)
       port ||= determine_port
       return if @thread && @thread.alive?
       serve_on_port(port) do
         @thread = Thread.new do
+          begin
           ::Rack::Handler::WEBrick.run(self,
                                        :Port => port,
                                        :Logger => WEBrick::Log.new("/dev/null"),
                                        :AccessLog => [nil, nil])
+          rescue Errno::EADDRINUSE => ex
+            msg = "Port #{port} for FakeCollector was in use"
+            if !@seen_port_failure
+              # This is slow, so only do it the first collision we detect
+              lsof = `lsof | grep #{port}`
+              msg = msg + "\n#{lsof}"
+              @seen_port_failure = true
+            end
+
+            raise Errno::EADDRINUSE.new(msg)
+          end
         end
         @thread.abort_on_exception = true
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 3.5.6.42.beta
+  version: 3.5.6.46.beta
   prerelease: 9
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-16 00:00:00.000000000 Z
+date: 2013-01-22 00:00:00.000000000 Z
 dependencies: []
 description: ! 'New Relic is a performance management system, developed by New Relic,