newrelic_rpm 3.2.0.beta1 → 3.2.0.beta2

data/CHANGELOG

@@ -1,11 +1,12 @@
 v3.2.0
   * Fix over-detection of mongrel and unicorn and only start the agent when
     actual server is running
-  * Improve developer mode backtraces to support ruby 1.9.2, windows, and fix
-    nil de-reference in developer mode
+  * Improve developer mode backtraces to support ruby 1.9.2, windows
   * Fixed some cases where Memcache instrumentation was failing to load
-  * Added View instrumentation back for Rails 3.1
   * Ability to set log destination by NEW_RELIC_LOG env var
+  * Fix to mutex lib load issue
+  * Performance enhancements (thanks to Jeremy Kemper)
+  * Fix overly verbose STDOUT message (thanks to Anselm Helbig)
   
 v3.1.2
   * Fixed some thread safety issues

data/lib/new_relic/agent/agent.rb

@@ -329,8 +329,8 @@ module NewRelic
           # we should not set an at_exit block if people are using
           # these as they don't do standard at_exit behavior per MRI/YARV
           def weird_ruby?
-            NewRelic::LanguageSupport.using_rubinius? ||
-              NewRelic::LanguageSupport.using_jruby? ||
+            NewRelic::LanguageSupport.using_engine?('rbx') ||
+              NewRelic::LanguageSupport.using_engine?('jruby') ||
               using_sinatra?
           end
 
@@ -469,7 +469,7 @@ module NewRelic
           def check_sql_sampler_status
             # disable sql sampling if disabled by the server
             # and we're not in dev mode
-            if control.developer_mode? || @should_send_samples
+            if @sql_sampler.config.fetch('enabled', true) && ['raw', 'obfuscated'].include?(@sql_sampler.config.fetch('record_sql', 'obfuscated').to_s)
               @sql_sampler.enable
             else
               @sql_sampler.disable
@@ -757,10 +757,9 @@ module NewRelic
           def config_transaction_tracer
             # Reconfigure the transaction tracer
             @transaction_sampler.configure!
+            @sql_sampler.configure!
             @should_send_samples = @config_should_send_samples = sampler_config.fetch('enabled', true)
             @should_send_random_samples = sampler_config.fetch('random_sample', false)
-            @explain_threshold = sampler_config.fetch('explain_threshold', 0.5).to_f
-            @explain_enabled = sampler_config.fetch('explain_enabled', true)
             set_sql_recording!
 
             # default to 2.0, string 'apdex_f' will turn into your
@@ -829,7 +828,7 @@ module NewRelic
 
           # gets the sampler configuration from the control object's settings
           def sampler_config
-            control.fetch('transaction_tracer', {})
+            NewRelic::Control.instance.fetch('transaction_tracer', {})
           end
 
           # Asks the collector to tell us which sub-collector we
@@ -1069,7 +1068,9 @@ module NewRelic
             begin
               options = { :keep_backtraces => true }
               options[:record_sql] = @record_sql unless @record_sql == :off
-              options[:explain_sql] = @explain_threshold if @explain_enabled
+              if @transaction_sampler.explain_enabled
+                options[:explain_sql] = @transaction_sampler.explain_threshold
+              end
               traces = @traces.collect {|trace| trace.prepare_to_send(options)}
               invoke_remote :transaction_sample_data, @agent_id, traces
             rescue PostTooBigException

data/lib/new_relic/agent/sql_sampler.rb

@@ -18,10 +18,7 @@ module NewRelic
       attr_reader :sql_traces
 
       def initialize
-        config = NewRelic::Control.instance
-        sampler_config = config.fetch('transaction_tracer', {})
-        @explain_threshold = sampler_config.fetch('explain_threshold', 0.5).to_f
-#        @stack_trace_threshold = sampler_config.fetch('stack_trace_threshold', 0.500).to_f
+        configure!
         @sql_traces = {}
         clear_transaction_data
 
@@ -30,7 +27,21 @@ module NewRelic
         # any 'honest-to-god'-multithreaded system
         @samples_lock = Mutex.new
       end
+      
+      def configure!
+        @explain_threshold = config.fetch('explain_threshold', 0.5).to_f
+        @explain_enabled = config.fetch('explain_enabled', true)
+        @stack_trace_threshold = config.fetch('stack_trace_threshold',
+                                              0.5).to_f
+        # config.fetch('enabled', true) ? self.enable : self.disable
+      end
 
+      def config
+        control = NewRelic::Control.instance
+        control.fetch('slow_sql',
+                      control.fetch('transaction_tracer', {}))
+      end
+      
       # Enable the sql sampler - this also registers it with
       # the statistics engine.
       def enable
@@ -45,6 +56,10 @@ module NewRelic
         NewRelic::Agent.instance.stats_engine.remove_sql_sampler(self)
       end
 
+      def enabled?
+        !@disabled
+      end
+
       def notice_transaction(path, uri=nil, params={})
         transaction_data.set_transaction_info(path, uri, params) if !disabled && transaction_data
       end
@@ -82,13 +97,13 @@ module NewRelic
       # this should always be called under the @samples_lock
       def harvest_slow_sql(transaction_sql_data)
         transaction_sql_data.sql_data.each do |sql_item|
-          obfuscated_sql = sql_item.normalize
-          sql_trace = @sql_traces[obfuscated_sql]
+          normalized_sql = sql_item.normalize
+          sql_trace = @sql_traces[normalized_sql]
           if sql_trace
             sql_trace.aggregate(sql_item, transaction_sql_data.path,
                                 transaction_sql_data.uri)
           else
-            @sql_traces[obfuscated_sql] = SqlTrace.new(obfuscated_sql,
+            @sql_traces[normalized_sql] = SqlTrace.new(normalized_sql,
                 sql_item, transaction_sql_data.path, transaction_sql_data.uri)
           end
         end
@@ -167,7 +182,7 @@ module NewRelic
 
       def normalize
         NewRelic::Agent::Database::Obfuscator.instance \
-          .default_sql_obfuscator(@sql).gsub(/\?\s*\,\s*/, '')
+          .default_sql_obfuscator(@sql).gsub(/\?\s*\,\s*/, '').gsub(/\s/, '')
       end
 
       def explain
@@ -183,10 +198,10 @@ module NewRelic
       attr_reader :database_metric_name
       attr_reader :params
 
-      def initialize(obfuscated_sql, slow_sql, path, uri)
+      def initialize(normalized_query, slow_sql, path, uri)
         super()
         @params = {} #FIXME
-        @sql_id = obfuscated_sql.hash
+        @sql_id = consistent_hash(normalized_query)
         set_primary slow_sql, path, uri
         record_data_point slow_sql.duration
       end
@@ -211,20 +226,43 @@ module NewRelic
       
       def prepare_to_send
         begin
-          params[:explain_plan] = @slow_sql.explain
+          params[:explain_plan] = @slow_sql.explain if need_to_explain?
         ensure
           NewRelic::Agent::Database.close_connections
         end
         @sql = @slow_sql.obfuscate if need_to_obfuscate?
       end
-
+      
+      def agent_config
+        control = NewRelic::Control.instance
+        control.fetch('slow_sql',
+                      control.fetch('transaction_tracer', {}))
+      end
+      
       def need_to_obfuscate?
-        NewRelic::Control.instance['transaction_tracer']['record_sql'] == 'obfuscated'
+        agent_config['record_sql'] == 'obfuscated'
+      end
+
+      def need_to_explain?
+        agent_config['explain_enabled']
       end
       
       def to_json(*a)
         [@path, @url, @sql_id, @sql, @database_metric_name, @call_count, @total_call_time, @min_call_time, @max_call_time, @params].to_json(*a)
       end
+
+      private
+
+      def consistent_hash(string)
+        if NewRelic::LanguageSupport.using_version?('1.9.2')
+          # String#hash is salted differently on every VM start in 1.9
+          # modulo ensures sql_id fits in an INT(11)
+          require 'digest/md5'
+          Digest::MD5.hexdigest(string).hex.modulo(2**31-1)
+        else
+          string.hash
+        end
+      end
     end
   end
 end

data/lib/new_relic/agent/stats_engine/metric_stats.rb

@@ -1,4 +1,3 @@
-require 'sync'
 require 'new_relic/language_support'
 
 module NewRelic
@@ -10,22 +9,25 @@ module NewRelic
         # are internally consistent even in truly-threaded rubies like JRuby
         class SynchronizedHash < ::Hash
           include NewRelic::LanguageSupport::SynchronizedHash
-          include Sync_m
+          
+          def initialize
+            @lock = Mutex.new
+          end
           
           def []=(*args)
-            sync_synchronize { super }
+            @lock.synchronize { super }
           end
 
           def clear(*args)
-            sync_synchronize { super }
+            @lock.synchronize { super }
           end
 
           def delete(*args)
-            sync_synchronize { super }
+            @lock.synchronize { super }
           end
 
           def delete_if(*args)
-            sync_synchronize { super }
+            @lock.synchronize { super }
           end
         end
         

data/lib/new_relic/agent/transaction_sampler.rb

@@ -19,6 +19,7 @@ module NewRelic
       BUILDER_KEY = :transaction_sample_builder
 
       attr_accessor :stack_trace_threshold, :random_sampling, :sampling_rate
+      attr_accessor :explain_threshold, :explain_enabled, :transaction_threshold
       attr_reader :samples, :last_sample, :disabled
 
       def initialize
@@ -46,9 +47,14 @@ module NewRelic
         # suffice for most customers
         config = NewRelic::Control.instance
         sampler_config = config.fetch('transaction_tracer', {})
+        
+        # enable if sampler_config.fetch('enabled', true)
+        
         @segment_limit = sampler_config.fetch('limit_segments', 4000)
         @stack_trace_threshold = sampler_config.fetch('stack_trace_threshold', 0.500).to_f
         @explain_threshold = sampler_config.fetch('explain_threshold', 0.5).to_f
+        @explain_enabled = sampler_config.fetch('explain_enabled', true)
+        @transaction_threshold = sampler_config.fetch('transation_threshold', 2.0)
       end
 
       # Returns the current sample id, delegated from `builder`
@@ -71,6 +77,10 @@ module NewRelic
         NewRelic::Agent.instance.stats_engine.remove_transaction_sampler(self)
       end
 
+      def enabled?
+        !@disabled
+      end
+
       # Set with an integer value n, this takes one in every n
       # harvested samples. It also resets the harvest count to a
       # random integer between 0 and (n-1)

data/lib/new_relic/control/frameworks/rails.rb

@@ -87,7 +87,7 @@ module NewRelic
 
         def log!(msg, level=:info)
           if should_log?
-            logger = ::Rails.respond_to?(:logger) ? Rails.logger : ::RAILS_DEFAULT_LOGGER
+            logger = ::Rails.respond_to?(:logger) ? ::Rails.logger : ::RAILS_DEFAULT_LOGGER
             logger.send(level, msg)
           else
             super
@@ -97,7 +97,7 @@ module NewRelic
         end
 
         def to_stdout(message)
-          logger = ::Rails.respond_to?(:logger) ? Rails.logger : ::RAILS_DEFAULT_LOGGER
+          logger = ::Rails.respond_to?(:logger) ? ::Rails.logger : ::RAILS_DEFAULT_LOGGER
           logger.info(message)
         rescue Exception => e
           super

data/lib/new_relic/delayed_job_injection.rb

@@ -12,6 +12,8 @@ module NewRelic
 end
 
 DependencyDetection.defer do
+  @name = :delayed_job_injection
+  
   depends_on do
     defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Control.instance['disable_dj']
   end

data/lib/new_relic/language_support.rb

@@ -4,9 +4,9 @@ module NewRelic::LanguageSupport
   module DataSerialization
     def self.included(base)
       # need to disable GC during marshal load in 1.8.7
-      if ::RUBY_VERSION == '1.8.7' &&
-          !NewRelic::LanguageSupport.using_jruby? &&
-          !NewRelic::LanguageSupport.using_rubinius?
+      if NewRelic::LanguageSupport.using_version?('1.8.7') &&
+          !NewRelic::LanguageSupport.using_engine?('jruby') &&
+          !NewRelic::LanguageSupport.using_engine?('rbx')
         base.class_eval do
           def self.load(*args)
             if defined?(::GC) && ::GC.respond_to?(:disable)
@@ -43,24 +43,27 @@ module NewRelic::LanguageSupport
   module SynchronizedHash
     def self.included(base)
       # need to lock iteration of stats hash in 1.9.x
-      if ::RUBY_VERSION.split('.')[0,2] == ['1','9'] ||
-          NewRelic::LanguageSupport.using_jruby?
+      if NewRelic::LanguageSupport.using_version?('1.9') ||
+          NewRelic::LanguageSupport.using_engine?('jruby')
         base.class_eval do
           def each(*args, &block)
-            sync_synchronize(:SH) { super }
+            @lock.synchronize { super }
           end
         end
       end
     end
   end
-
-  # Are we in boss mode, using rubinius?
-  def using_rubinius?
-    defined?(::RUBY_ENGINE) && ::RUBY_ENGINE == 'rbx'
+  
+  def using_engine?(engine)
+    if defined?(::RUBY_ENGINE)
+      ::RUBY_ENGINE == engine
+    else
+      engine == 'ruby'
+    end
   end
-
-  # Is this really a world-within-a-world, running JRuby?
-  def using_jruby?
-    defined?(::RUBY_ENGINE) && ::RUBY_ENGINE == 'jruby'
+  
+  def using_version?(version)
+    numbers = version.split('.')
+    numbers == ::RUBY_VERSION.split('.')[0, numbers.size]
   end
 end

data/lib/new_relic/local_environment.rb

@@ -333,7 +333,6 @@ module NewRelic
       if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
         v = find_class_in_object_space(::Unicorn::HttpServer)
         @dispatcher = :unicorn if v 
-        puts "We DETECTED UNICORN???: #{v.inspect}"
       end
     end
 

data/lib/new_relic/transaction_sample/segment.rb

@@ -32,7 +32,7 @@ module NewRelic
         to_debug_str(0)
       end
 
-      def to_json
+      def to_json(options={})
         hash = {
           :entry_timestamp => @entry_timestamp,
           :exit_timestamp => @exit_timestamp,

data/lib/new_relic/version.rb

@@ -4,7 +4,7 @@ module NewRelic
     MAJOR = 3
     MINOR = 2
     TINY  = 0
-    BUILD = 'beta1' #'0' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    BUILD = 'beta2' #'0' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
 

data/newrelic_rpm.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{newrelic_rpm}
-  s.version = "3.2.0.beta1"
+  s.version = "3.2.0.beta2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Bill Kayser", "Jon Guymon", "Justin George", "Darin Swanson"]
-  s.date = %q{2011-09-23}
+  s.authors = [%q{Bill Kayser}, %q{Jon Guymon}, %q{Justin George}, %q{Darin Swanson}]
+  s.date = %q{2011-10-13}
   s.description = %q{New Relic is a performance management system, developed by New Relic,
 Inc (http://www.newrelic.com).  New Relic provides you with deep
 information about the performance of your web application as it runs
@@ -18,7 +18,7 @@ Gem or plugin, hosted on
 http://github.com/newrelic/rpm/
 }
   s.email = %q{support@newrelic.com}
-  s.executables = ["mongrel_rpm", "newrelic", "newrelic_cmd"]
+  s.executables = [%q{mongrel_rpm}, %q{newrelic}, %q{newrelic_cmd}]
   s.extra_rdoc_files = [
     "CHANGELOG",
     "LICENSE",
@@ -305,9 +305,9 @@ for a complete description of the features and enhancements available
 in version 3.2 of the Ruby Agent.
   
 }
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "New Relic Ruby Agent"]
-  s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.6}
+  s.rdoc_options = [%q{--line-numbers}, %q{--inline-source}, %q{--title}, %q{New Relic Ruby Agent}]
+  s.require_paths = [%q{lib}]
   s.summary = %q{New Relic Ruby Agent}
 
   if s.respond_to? :specification_version then

data/test/new_relic/agent/agent/connect_test.rb

@@ -207,19 +207,22 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_config_transaction_tracer
-    @transaction_sampler = mock('transaction sampler', :configure! => true)
-    fake_sampler_config = mock('sampler config')
-    self.expects(:sampler_config).times(5).returns(fake_sampler_config)
-    fake_sampler_config.expects(:fetch).with('enabled', true)
-    fake_sampler_config.expects(:fetch).with('random_sample', false)
-    fake_sampler_config.expects(:fetch).with('explain_threshold', 0.5)
-    fake_sampler_config.expects(:fetch).with('explain_enabled', true)
-    self.expects(:set_sql_recording!)
-
-    fake_sampler_config.expects(:fetch).with('transaction_threshold', 2.0)
-    self.expects(:apdex_f_threshold?).returns(true)
-    self.expects(:apdex_f)
+    NewRelic::Control.instance.settings['transaction_tracer'] = {
+      'enabled' => true,
+      'random_sample' => false,
+      'explain_threshold' => 0.75,
+      'explain_enabled' => true
+    }
+    
+    @transaction_sampler = NewRelic::Agent::TransactionSampler.new
+    @sql_sampler = NewRelic::Agent::SqlSampler.new
+
     config_transaction_tracer
+
+    assert @transaction_sampler.enabled?
+    assert_equal 0.75, @transaction_sampler.explain_threshold
+    assert @transaction_sampler.explain_enabled
+#     assert_equal 1.5, @transaction_sampler.transaction_threshold
   end
 
   def test_configure_transaction_tracer_with_random_sampling
@@ -319,8 +322,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_sampler_config
-    control = mocked_control
-    control.expects(:fetch).with('transaction_tracer', {})
+    NewRelic::Control.instance.expects(:fetch).with('transaction_tracer', {})
     sampler_config
   end
 
@@ -365,12 +367,12 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
       'collect_errors' => true,
       'sample_rate' => 10
     }
-    control = mocked_control
-    control.expects(:fetch).with('transaction_tracer', {}).returns({'enabled' => true}).at_least_once
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'enabled' => true}
     self.expects(:log_connection!).with(config)
     self.expects(:configure_transaction_tracer!).with(true, 10)
     self.expects(:configure_error_collector!).with(true)
     @transaction_sampler = mock('transaction sampler', :configure! => true)
+    @sql_sampler = mock('sql sampler', :configure! => true)    
     finish_setup(config)
     assert_equal 'fishsticks', @agent_id
     assert_equal 'pasta sauce', @report_period

data/test/new_relic/agent/agent/start_test.rb

@@ -105,8 +105,8 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   def test_install_exit_handler_positive
     control = mocked_control
     control.expects(:send_data_on_exit).returns(true)
-    NewRelic::LanguageSupport.expects(:using_rubinius?).returns(false)
-    NewRelic::LanguageSupport.expects(:using_jruby?).returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
     self.expects(:using_sinatra?).returns(false)
     # we are overriding at_exit above, to immediately return, so we can
     # test the shutdown logic. It's somewhat unfortunate, but we can't
@@ -124,14 +124,14 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   def test_install_exit_handler_weird_ruby
     control = mocked_control
     control.expects(:send_data_on_exit).times(3).returns(true)
-    NewRelic::LanguageSupport.expects(:using_rubinius?).returns(false)
-    NewRelic::LanguageSupport.expects(:using_jruby?).returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
     self.expects(:using_sinatra?).returns(true)
     install_exit_handler
-    NewRelic::LanguageSupport.expects(:using_rubinius?).returns(false)
-    NewRelic::LanguageSupport.expects(:using_jruby?).returns(true)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(true)
     install_exit_handler
-    NewRelic::LanguageSupport.expects(:using_rubinius?).returns(true)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(true)
     install_exit_handler
   end
 

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -75,8 +75,8 @@ var e=document.createElement("script");'
   end
 
   def test_browser_timing_footer_without_calling_header
-    footer = browser_timing_footer
-    assert_equal "", footer
+    Thread.current[:newrelic_start_time] = nil    
+    assert_equal "", browser_timing_footer
   end
 
   def test_browser_timing_footer_with_no_browser_key_rum_enabled

data/test/new_relic/agent/database_test.rb

@@ -156,5 +156,7 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     end
     
     assert_equal "12" + sql + "3", NewRelic::Agent::Database.obfuscate_sql(sql)
+
+    NewRelic::Agent::Database::Obfuscator.instance.reset
   end
 end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -95,7 +95,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     data = NewRelic::Agent::TransactionSqlData.new
     data.set_transaction_info "WebTransaction/Controller/c/a", "/c/a", {}
     queries = [
-               NewRelic::Agent::SlowSql.new("select * from test where foo in (1, 2)", "Database/test/select", {}, 1.5), 
+               NewRelic::Agent::SlowSql.new("select  * from test where foo in (1, 2)  ", "Database/test/select", {}, 1.5), 
                NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2, 3 ,4,  5,6, 'snausage')", "Database/test/select", {}, 1.2), 
                NewRelic::Agent::SlowSql.new("select * from test2 where foo in (1,2)", "Database/test2/select", {}, 1.1)
               ]
@@ -132,4 +132,29 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     assert_equal(["bar0", "bar1", "bar2"],
                  sql_traces[1].params[:explain_plan][1][0].sort)
   end
+
+  def test_should_not_collect_explain_plans_when_disabled
+    NewRelic::Control.instance['slow_sql'] = { 'explain_enabled' => false }
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info "WebTransaction/Controller/c/a", "/c/a", {}
+    
+    queries = [
+               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5)
+              ]
+    data.sql_data.concat(queries)
+    @sampler.harvest_slow_sql data   
+    sql_traces = @sampler.harvest
+    assert_equal(nil, sql_traces[0].params[:explain_plan])
+    NewRelic::Control.instance['slow_sql'] = { 'explain_enabled' => true }
+  end
+
+  def test_sql_id_fits_in_a_mysql_int_11
+    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test", 
+            NewRelic::Agent::SlowSql.new("select * from test",
+                "Database/test/select", {}, 1.2),
+        "tx_name", "uri")
+    
+    assert -2147483648 <= sql_trace.sql_id, "sql_id too small"
+    assert 2147483647 >= sql_trace.sql_id, "sql_id too large"
+  end
 end

data/test/new_relic/agent/stats_engine/metric_stats_test.rb

@@ -9,6 +9,7 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     puts e
     puts e.backtrace.join("\n")
   end
+  
   def teardown
     @engine.harvest_timeslice_data({},{})
     super
@@ -28,6 +29,7 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
   end
 
   def test_harvest
+    @engine.clear_stats
     s1 = @engine.get_stats "a"
     s2 = @engine.get_stats "c"
 
@@ -35,47 +37,46 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     s2.trace_call 1
     s2.trace_call 3
 
-    assert @engine.get_stats("a").call_count == 1
-    assert @engine.get_stats("a").total_call_time == 10
+    assert_equal 1, @engine.get_stats("a").call_count
+    assert_equal 10, @engine.get_stats("a").total_call_time
 
-    assert @engine.get_stats("c").call_count == 2
-    assert @engine.get_stats("c").total_call_time == 4
+    assert_equal 2, @engine.get_stats("c").call_count
+    assert_equal 4, @engine.get_stats("c").total_call_time
 
     metric_data = @engine.harvest_timeslice_data({}, {}).values
-
+    
     # after harvest, all the metrics should be reset
-    assert @engine.get_stats("a").call_count == 0
-    assert @engine.get_stats("a").total_call_time == 0
+    assert_equal 0, @engine.get_stats("a").call_count
+    assert_equal 0, @engine.get_stats("a").total_call_time
 
-    assert @engine.get_stats("c").call_count == 0
-    assert @engine.get_stats("c").total_call_time == 0
+    assert_equal 0, @engine.get_stats("c").call_count
+    assert_equal 0, @engine.get_stats("c").total_call_time
 
     metric_data = metric_data.reverse if metric_data[0].metric_spec.name != "a"
 
-    assert metric_data[0].metric_spec.name == "a"
+    assert_equal 'a', metric_data[0].metric_spec.name
 
-    assert metric_data[0].stats.call_count == 1
-    assert metric_data[0].stats.total_call_time == 10
+    assert_equal 1, metric_data[0].stats.call_count
+    assert_equal 10, metric_data[0].stats.total_call_time
   end
 
   def test_harvest_with_merge
     s = @engine.get_stats "a"
     s.trace_call 1
 
-    assert @engine.get_stats("a").call_count == 1
+    assert_equal 1, @engine.get_stats("a").call_count
 
     harvest = @engine.harvest_timeslice_data({}, {})
-    assert s.call_count == 0
+    assert_equal 0, s.call_count
     s.trace_call 2
-    assert s.call_count == 1
+    assert_equal 1, s.call_count
 
     # this calk should merge the contents of the previous harvest,
     # so the stats for metric "a" should have 2 data points
     harvest = @engine.harvest_timeslice_data(harvest, {})
     stats = harvest.fetch(NewRelic::MetricSpec.new("a")).stats
-    assert stats.call_count == 2
-    assert stats.total_call_time == 3
+    assert_equal 2, stats.call_count
+    assert_equal 3, stats.total_call_time
   end
-
 end
 

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -650,6 +650,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     @sampler.expects(:disabled).returns(false)
     @sampler.send(:start_builder)
     assert_equal(fake_builder, Thread.current[:transaction_sample_builder], "should not overwrite an existing transaction sample builder")
+    Thread.current[:transaction_sample_builder] = nil
   end
 
   def test_builder

data/test/new_relic/control/configuration_test.rb

@@ -12,7 +12,7 @@ class NewRelic::Control::ConfigurationTest < Test::Unit::TestCase
   end
   
   def teardown
-    NewRelic::Control.instance.settings.delete 'log_file_path'
+    NewRelic::Control.instance.settings.delete('log_file_path')
   end
   
   def test_license_key_defaults_to_env_variable
@@ -37,6 +37,7 @@ class NewRelic::Control::ConfigurationTest < Test::Unit::TestCase
     NewRelic::Control.instance.setup_log
     assert_match(/\/lerg\/newrelic_agent.log/,
                  NewRelic::Control.instance.log_file)
+    NewRelic::Control.instance.settings.delete('log_file_path') # = nil    
   end
 
   def test_server_side_config_ignores_yaml

data/test/new_relic/control_test.rb

@@ -1,22 +1,22 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
 class NewRelic::ControlTest < Test::Unit::TestCase
 
-  attr_reader :c
+  attr_reader :control
 
   def setup
-
     NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
-    @c =  NewRelic::Control.instance
+    @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 @c.cert_file_path
-    assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @c.cert_file_path
-  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
@@ -27,7 +27,7 @@ class NewRelic::ControlTest < Test::Unit::TestCase
 
     s   = TCPSocket.new 'collector.newrelic.com', 443
     ctx = OpenSSL::SSL::SSLContext.new
-    ctx.ca_file = @c.cert_file_path
+    ctx.ca_file = @control.cert_file_path
     ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
     s   = OpenSSL::SSL::SSLSocket.new s, ctx
     s.connect
@@ -43,7 +43,7 @@ class NewRelic::ControlTest < Test::Unit::TestCase
 
     s   = TCPSocket.new 'staging-collector.newrelic.com', 443
     ctx = OpenSSL::SSL::SSLContext.new
-    ctx.ca_file = @c.cert_file_path
+    ctx.ca_file = @control.cert_file_path
     ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
     s   = OpenSSL::SSL::SSLSocket.new s, ctx
     s.connect
@@ -51,39 +51,39 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_monitor_mode
-    assert ! @c.monitor_mode?
-    @c.settings.delete 'enabled'
-    @c.settings.delete 'monitor_mode'
-    assert !@c.monitor_mode?
-    @c['enabled'] = false
-    assert ! @c.monitor_mode?
-    @c['enabled'] = true
-    assert @c.monitor_mode?
-    @c['monitor_mode'] = nil
-    assert !@c.monitor_mode?
-    @c['monitor_mode'] = false
-    assert !@c.monitor_mode?
-    @c['monitor_mode'] = true
-    assert @c.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
-    @c['enabled'] = false
-    @c['monitor_mode'] = false
+    @control['enabled'] = false
+    @control['monitor_mode'] = false
   end
 
   def test_test_config
     if defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
-      assert_equal :rails3, c.app
+      assert_equal :rails3, control.app
     elsif defined?(Rails)
-      assert_equal :rails, c.app
+      assert_equal :rails, control.app
     else
-      assert_equal :test, c.app
+      assert_equal :test, control.app
     end
-    assert_equal :test, c.framework
-    assert_match /test/i, c.dispatcher_instance_id
-    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
+    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
@@ -101,10 +101,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_resolve_ip
-    assert_equal nil, c.send(:convert_to_ip_address, 'localhost')
-    assert_equal nil, c.send(:convert_to_ip_address, 'q1239988737.us')
+    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', c.send(:convert_to_ip_address, 'collector.newrelic.com')
+    assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
   end
 
   class FakeResolv
@@ -120,7 +120,7 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     old_ipsocket = IPSocket
     Object.instance_eval { remove_const :Resolv}
     Object.instance_eval {remove_const:'IPSocket' }
-    assert_equal(nil, c.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+    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
@@ -129,12 +129,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     assert_equal old_ipsocket, IPSocket
   end
 
-
-
   def test_config_yaml_erb
-    assert_equal 'heyheyhey', c['erb_value']
-    assert_equal '', c['message']
-    assert_equal '', c['license_key']
+    assert_equal 'heyheyhey', control['erb_value']
+    assert_equal '', control['message']
+    assert_equal '', control['license_key']
   end
 
   def test_appnames
@@ -142,22 +140,25 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_config_booleans
-    assert_equal c['tval'], true
-    assert_equal c['fval'], false
-    assert_nil c['not_in_yaml_val']
-    assert_equal c['yval'], true
-    assert_equal c['sval'], 'sure'
+    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, c.apdex_t
+    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$/, c.instance_variable_get('@log_file')
+    assert_match /newrelic_agent.log$/, control.instance_variable_get('@log_file')
   end
 
 #  def test_transaction_threshold__apdex
@@ -167,25 +168,57 @@ class NewRelic::ControlTest < Test::Unit::TestCase
 #  end
 
   def test_transaction_threshold__default
-
     forced_start :transaction_tracer => { :transaction_threshold => nil}
-    assert_nil c['transaction_tracer']['transaction_threshold']
+    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, c['transaction_tracer']['transaction_threshold']
+    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_merging_options
     NewRelic::Control.send :public, :merge_options
-    @c.merge_options :api_port => 66, :transaction_tracer => { :explain_threshold => 2.0 }
+    @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.

data/test/new_relic/data_serialization_test.rb

@@ -16,6 +16,7 @@ class NewRelic::DataSerializationTest < Test::Unit::TestCase
   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
@@ -71,7 +72,6 @@ class NewRelic::DataSerializationTest < Test::Unit::TestCase
   end
 
   def test_should_send_data_when_over_limit
-#    NewRelic::DataSerialization.expects(:max_size).returns(20)
     NewRelic::DataSerialization.stubs(:max_size).returns(20)
     NewRelic::DataSerialization.read_and_write_to_file do
       "a" * 30
@@ -103,17 +103,18 @@ class NewRelic::DataSerializationTest < Test::Unit::TestCase
   end
 
   def test_should_send_data_disabled
-    NewRelic::Control.instance.expects(:disable_serialization?).returns(true)
-    assert(NewRelic::DataSerialization.should_send_data?, 'should send data when 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 |
+    NewRelic::DataSerialization.read_and_write_to_file do |old_data|
       "a" * 5
     end
     
-    assert(!NewRelic::DataSerialization.should_send_data?,
+    assert(!NewRelic::DataSerialization.store_too_large?,
            'Should be under the limit')
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 3.2.0.beta1
+  version: 3.2.0.beta2
   prerelease: 6
 platform: ruby
 authors:
@@ -12,12 +12,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-23 00:00:00.000000000 -07:00
-default_executable: 
+date: 2011-10-13 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2173242300 !ruby/object:Gem::Requirement
+  requirement: &2153262420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -25,10 +24,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2173242300
+  version_requirements: *2153262420
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &2173241580 !ruby/object:Gem::Requirement
+  requirement: &2153261700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -36,10 +35,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2173241580
+  version_requirements: *2153261700
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &2173239980 !ruby/object:Gem::Requirement
+  requirement: &2153261000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -47,7 +46,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2173239980
+  version_requirements: *2153261000
 description: ! 'New Relic is a performance management system, developed by New Relic,
 
   Inc (http://www.newrelic.com).  New Relic provides you with deep
@@ -329,7 +328,6 @@ files:
 - vendor/gems/metric_parser-0.1.0.pre1/lib/new_relic/metric_parser/web_frontend.rb
 - vendor/gems/metric_parser-0.1.0.pre1/lib/new_relic/metric_parser/web_service.rb
 - vendor/gems/metric_parser-0.1.0.pre1/lib/new_relic/metric_parser/web_transaction.rb
-has_rdoc: true
 homepage: http://www.github.com/newrelic/rpm
 licenses: []
 post_install_message: ! "\nPLEASE NOTE:\n\nDeveloper Mode is now a Rack middleware.\n\nDeveloper
@@ -362,7 +360,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: New Relic Ruby Agent