newrelic_rpm 3.1.2 → 3.2.0.beta1

data/lib/new_relic/control/configuration.rb

@@ -49,6 +49,27 @@ module NewRelic
         end
       end
 
+      def merge_server_side_config(data)
+        remove_server_controlled_configs
+        config = Hash.new
+        data.each_pair do |key, value|
+          if key.include?('.')
+            key = key.split('.')
+            config[key.first] ||= Hash.new
+            config[key.first][key[1]] = value
+          else
+            config[key] = value
+          end
+        end
+        merge_options(config)
+      end
+
+      def remove_server_controlled_configs
+        settings.delete('transaction_tracer')
+        settings.delete('error_collector')
+        settings.delete('capture_params')
+      end
+
       def [](key)
         fetch(key)
       end

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

@@ -80,7 +80,7 @@ module NewRelic
             rescue Exception => e
               log!("Error installing New Relic Developer Mode: #{e.inspect}", :error)
             end
-          else
+          elsif rails_config
             log!("Developer mode not available for Rails versions prior to 2.2", :warn)
           end
         end

data/lib/new_relic/control/logging_methods.rb

@@ -91,15 +91,21 @@ module NewRelic
       end
       
       # Sets up and caches the log path, attempting to create it if it
-      # does not exist. this comes from the configuration variable
-      # 'log_file_path' in the configuration file.
+      # does not exist.  If it does not succeed, it prints an
+      # error and returns nil.
+      # This comes from the configuration variable 'log_file_path' in the configuration file.
       def log_path
         return @log_path if @log_path
         if log_to_stdout?
           @log_path = nil
         else
-          @log_path = find_or_create_file_path(fetch('log_file_path', 'log'))
-          log!("Error creating log directory for New Relic log file, using standard out.", :error) unless @log_path
+          if ENV['NEW_RELIC_LOG']
+            log_path_setting = File.dirname(ENV['NEW_RELIC_LOG'])
+          else
+            log_path_setting = fetch('log_file_path', 'log')
+          end
+          @log_path = find_or_create_file_path(log_path_setting)
+          log!("Error creating log directory #{log_path_setting}, using standard out for logging.", :warn) unless @log_path
         end
         @log_path
       end
@@ -116,7 +122,8 @@ module NewRelic
 
       def log_to_stdout?
         return true if @stdout
-        if fetch('log_file_path', 'log') == 'STDOUT'
+        destination = ENV['NEW_RELIC_LOG'] || fetch('log_file_path', 'log')
+        if destination.upcase == 'STDOUT'
           @stdout = true
         end
       end
@@ -124,7 +131,11 @@ module NewRelic
       # Retrieves the log file's name from the config file option
       #'log_file_name', defaulting to 'newrelic_agent.log'
       def log_file_name
-        fetch('log_file_name', 'newrelic_agent.log')
+        if ENV['NEW_RELIC_LOG']
+          File.basename(ENV['NEW_RELIC_LOG'])
+        else
+          fetch('log_file_name', 'newrelic_agent.log')
+        end
       end
     end
     include LoggingMethods

data/lib/new_relic/delayed_job_injection.rb

@@ -13,7 +13,7 @@ end
 
 DependencyDetection.defer do
   depends_on do
-    defined?(::Delayed) && defined?(::Delayed::Worker)
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Control.instance['disable_dj']
   end
   
   executes do

data/lib/new_relic/local_environment.rb

@@ -217,6 +217,7 @@ module NewRelic
       ObjectSpace.each_object(klass) do |x|
         return x
       end
+      return nil
     end
     
     # Sets the @mongrel instance variable if we can find a Mongrel::HttpServer
@@ -228,21 +229,13 @@ module NewRelic
       @mongrel
     end
     
-    # sets the @unicorn instance variable if we can find a Unicorn::HttpServer
-    def unicorn
-      return @unicorn if @unicorn
-      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
-        @unicorn = find_class_in_object_space(::Unicorn::HttpServer)
-      end
-      @unicorn
-    end
-
     private
 
     # Although you can override the framework with NEWRELIC_DISPATCHER this
     # is not advisable since it implies certain api's being available.
     def discover_dispatcher
       @dispatcher ||= ENV['NEWRELIC_DISPATCHER'] && ENV['NEWRELIC_DISPATCHER'].to_sym
+      @dispatcher ||= ENV['NEW_RELIC_DISPATCHER'] && ENV['NEW_RELIC_DISPATCHER'].to_sym
       dispatchers = %w[passenger torquebox glassfish thin mongrel litespeed webrick fastcgi unicorn sinatra]
       while dispatchers.any? && @dispatcher.nil?
         send 'check_for_'+(dispatchers.shift)
@@ -257,6 +250,7 @@ module NewRelic
       # of JRuby.
       @framework ||= case
                      when ENV['NEWRELIC_FRAMEWORK'] then ENV['NEWRELIC_FRAMEWORK'].to_sym
+                     when ENV['NEW_RELIC_FRAMEWORK'] then ENV['NEW_RELIC_FRAMEWORK'].to_sym
                      when defined?(::NewRelic::TEST) then :test
                      when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
                      when defined?(::Rails) then check_rails_version
@@ -336,11 +330,11 @@ module NewRelic
     end
 
     def check_for_unicorn
-      return unless defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
-
-      # unlike mongrel, unicorn manages muliple threads and ports, so we
-      # have to map multiple processes into one instance, as we do with passenger
-      @dispatcher = :unicorn
+      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
 
     def check_for_sinatra

data/lib/new_relic/rack/developer_mode.rb

@@ -67,6 +67,7 @@ module NewRelic
 
       def reset
         NewRelic::Agent.instance.transaction_sampler.reset!
+        NewRelic::Agent.instance.sql_sampler.reset
         ::Rack::Response.new{|r| r.redirect('/newrelic/')}.finish
       end
 

data/lib/new_relic/stats.rb

@@ -47,6 +47,7 @@ module NewRelic
     def sum_attributes(other)
       update_totals(other)
       stack_min_max_from(other)
+      self.call_count = [self.call_count, other.call_count].max
       update_boundaries(other)
     end
 

data/lib/new_relic/transaction_sample.rb

@@ -7,20 +7,6 @@ module NewRelic
   # into one segment with multiple executions
   COLLAPSE_SEGMENTS_THRESHOLD = 2
 
-  # columns for a mysql explain plan
-  MYSQL_EXPLAIN_COLUMNS = [
-        "Id",
-        "Select Type",
-        "Table",
-        "Type",
-        "Possible Keys",
-        "Key",
-        "Key Length",
-        "Ref",
-        "Rows",
-        "Extra"
-      ].freeze
-
   class TransactionSample
 
     attr_accessor :params, :root_segment
@@ -32,48 +18,7 @@ module NewRelic
     @@start_time = Time.now
 
     include TransactionAnalysis
-
-    class << self
-      def obfuscate_sql(sql)
-        NewRelic::Agent.instance.obfuscator.call(sql)
-      end
-      
-      # Returns a cached connection for a given ActiveRecord
-      # configuration - these are stored or reopened as needed, and if
-      # we cannot get one, we ignore it and move on without explaining
-      # the sql
-      def get_connection(config)
-        @@connections ||= {}
-
-        connection = @@connections[config]
-
-        return connection if connection
-
-        begin
-          connection = ActiveRecord::Base.send("#{config[:adapter]}_connection", config)
-          @@connections[config] = connection
-        rescue => e
-          NewRelic::Agent.agent.log.error("Caught exception #{e} trying to get connection to DB for explain. Control: #{config}")
-          NewRelic::Agent.agent.log.error(e.backtrace.join("\n"))
-          nil
-        end
-      end
-      
-      # Closes all the connections in the internal connection cache
-      def close_connections
-        @@connections ||= {}
-        @@connections.values.each do |connection|
-          begin
-            connection.disconnect!
-          rescue
-          end
-        end
-
-        @@connections = {}
-      end
-
-    end
-
+    
     def initialize(time = Time.now.to_f, sample_id = nil)
       @sample_id = sample_id || object_id
       @start_time = time
@@ -213,7 +158,7 @@ module NewRelic
       begin
         build_segment_for_transfer(sample, @root_segment, sample.root_segment, options)
       ensure
-        self.class.close_connections
+        NewRelic::Agent::Database.close_connections
       end
 
       sample.root_segment.end_trace(@root_segment.exit_timestamp)
@@ -280,9 +225,9 @@ module NewRelic
             end
             
             target_called_segment[:sql] = case options[:record_sql]
-            when :raw then v
-            when :obfuscated then TransactionSample.obfuscate_sql(v)
-            else raise "Invalid value for record_sql: #{options[:record_sql]}"
+              when :raw then v
+              when :obfuscated then NewRelic::Agent::Database.obfuscate_sql(v)
+              else raise "Invalid value for record_sql: #{options[:record_sql]}"
             end if options[:record_sql]
           when :connection_config
             # don't copy it

data/lib/new_relic/transaction_sample/segment.rb

@@ -174,95 +174,20 @@ module NewRelic
         end
         nil
       end
-
-      # Perform this in the runtime environment of a managed
-      # application, to explain the sql statement executed within a
-      # segment of a transaction sample. Returns an array of
-      # explanations (which is an array rows consisting of an array of
-      # strings for each column returned by the the explain query)
-      # Note this happens only for statements whose execution time
-      # exceeds a threshold (e.g. 500ms) and only within the slowest
-      # transaction in a report period, selected for shipment to New
-      # Relic
+      
       def explain_sql
-        return @explain_sql if @explain_sql
-        sql = params[:sql]
-        return nil unless sql && params[:connection_config]
-        statement = sql.split(";\n")[0] # only explain the first
-        @explain_sql = explain_statement(statement, params[:connection_config])
-        return @explain_sql || []
-      end
-
-      def explain_statement(statement, config)
-        if is_select?(statement)
-          handle_exception_in_explain do
-            connection = NewRelic::TransactionSample.get_connection(config)
-            plan = nil
-            if connection
-              plan = process_resultset(connection.execute("EXPLAIN #{statement}"))
-            end
-            return plan
-          end
-        end
+        NewRelic::Agent::Database.explain_sql(params[:sql],
+                                              params[:connection_config])
       end
-
-      def is_select?(statement)
-        # split the string into at most two segments on the
-        # system-defined field separator character
-        first_word, rest_of_statement = statement.split($;, 2)
-        (first_word.upcase == 'SELECT')
-      end
-
-      def process_resultset(items)
-        # The resultset type varies for different drivers.  Only thing you can count on is
-        # that it implements each.  Also: can't use select_rows because the native postgres
-        # driver doesn't know that method.
-        
-        headers = []
-        values = []
-        if items.respond_to?(:each_hash)
-          items.each_hash do |row|
-            headers = row.keys
-            values << headers.map{|h| row[h] }
-          end
-        elsif items.respond_to?(:each)
-          items.each do |row|
-            if row.kind_of?(Hash)
-              headers = row.keys
-              values << headers.map{|h| row[h] }
-            else
-              values << row
-            end
-          end
-        else
-          values = [items]
-        end
-        
-        headers = nil if headers.empty?
-        [headers, values]
-      end
-
-      def handle_exception_in_explain
-        yield
-      rescue Exception => e
-        begin
-          # guarantees no throw from explain_sql
-          NewRelic::Control.instance.log.error("Error getting query plan: #{e.message}")
-          NewRelic::Control.instance.log.debug(e.backtrace.join("\n"))
-        rescue Exception
-          # double exception. throw up your hands
-        end
+      
+      def obfuscated_sql
+        NewRelic::Agent::Database.obfuscate_sql(params[:sql])
       end
-
-
+      
       def params=(p)
         @params = p
       end
 
-      def obfuscated_sql
-        TransactionSample.obfuscate_sql(params[:sql])
-      end
-
       def called_segments=(segments)
         @called_segments = segments
       end

data/lib/new_relic/version.rb

@@ -2,9 +2,9 @@
 module NewRelic
   module VERSION #:nodoc:
     MAJOR = 3
-    MINOR = 1
-    TINY  = 2
-    BUILD = nil # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    MINOR = 2
+    TINY  = 0
+    BUILD = 'beta1' #'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.1.2"
+  s.version = "3.2.0.beta1"
 
   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-07}
+  s.date = %q{2011-09-23}
   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
@@ -44,6 +44,7 @@ http://github.com/newrelic/rpm/
     "lib/new_relic/agent/browser_monitoring.rb",
     "lib/new_relic/agent/busy_calculator.rb",
     "lib/new_relic/agent/chained_call.rb",
+    "lib/new_relic/agent/database.rb",
     "lib/new_relic/agent/error_collector.rb",
     "lib/new_relic/agent/instrumentation.rb",
     "lib/new_relic/agent/instrumentation/active_merchant.rb",
@@ -78,6 +79,7 @@ http://github.com/newrelic/rpm/
     "lib/new_relic/agent/samplers/memory_sampler.rb",
     "lib/new_relic/agent/samplers/object_sampler.rb",
     "lib/new_relic/agent/shim_agent.rb",
+    "lib/new_relic/agent/sql_sampler.rb",
     "lib/new_relic/agent/stats_engine.rb",
     "lib/new_relic/agent/stats_engine/metric_stats.rb",
     "lib/new_relic/agent/stats_engine/samplers.rb",
@@ -147,6 +149,7 @@ http://github.com/newrelic/rpm/
     "test/new_relic/agent/beacon_configuration_test.rb",
     "test/new_relic/agent/browser_monitoring_test.rb",
     "test/new_relic/agent/busy_calculator_test.rb",
+    "test/new_relic/agent/database_test.rb",
     "test/new_relic/agent/error_collector/notice_error_test.rb",
     "test/new_relic/agent/error_collector_test.rb",
     "test/new_relic/agent/instrumentation/active_record_instrumentation_test.rb",
@@ -166,6 +169,7 @@ http://github.com/newrelic/rpm/
     "test/new_relic/agent/rpm_agent_test.rb",
     "test/new_relic/agent/sampler_test.rb",
     "test/new_relic/agent/shim_agent_test.rb",
+    "test/new_relic/agent/sql_sampler_test.rb",
     "test/new_relic/agent/stats_engine/metric_stats/harvest_test.rb",
     "test/new_relic/agent/stats_engine/metric_stats_test.rb",
     "test/new_relic/agent/stats_engine/samplers_test.rb",
@@ -187,6 +191,7 @@ http://github.com/newrelic/rpm/
     "test/new_relic/metric_spec_test.rb",
     "test/new_relic/rack/all_test.rb",
     "test/new_relic/rack/browser_monitoring_test.rb",
+    "test/new_relic/rack/developer_mode_helper_test.rb",
     "test/new_relic/rack/developer_mode_test.rb",
     "test/new_relic/stats_test.rb",
     "test/new_relic/transaction_analysis/segment_summary_test.rb",
@@ -297,7 +302,7 @@ Refer to the README.md file for more information.
 
 Please see http://github.com/newrelic/rpm/blob/master/CHANGELOG
 for a complete description of the features and enhancements available
-in version 3.1 of the Ruby Agent.
+in version 3.2 of the Ruby Agent.
   
 }
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "New Relic Ruby Agent"]

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

@@ -206,6 +206,22 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     enable_random_samples!(sampling_rate)
   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)
+    config_transaction_tracer
+  end
+
   def test_configure_transaction_tracer_with_random_sampling
     @config_should_send_samples = true
     @should_send_random_samples = true
@@ -238,6 +254,76 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     assert !@should_send_samples
   end
 
+  def test_apdex_f
+    NewRelic::Control.instance.expects(:apdex_t).returns(10)
+    assert_equal 40, apdex_f
+  end
+
+  def test_apdex_f_threshold_positive
+    self.expects(:sampler_config).returns({'transaction_threshold' => 'apdex_f'})
+    assert apdex_f_threshold?
+  end
+
+  def test_apdex_f_threshold_negative
+    self.expects(:sampler_config).returns({'transaction_threshold' => 'WHEE'})
+    assert !apdex_f_threshold?
+  end
+
+  def test_set_sql_recording_default
+    self.expects(:sampler_config).returns({})
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :obfuscated, @record_sql, " should default to :obfuscated, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_off
+    self.expects(:sampler_config).returns({'record_sql' => 'off'})
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_none
+    self.expects(:sampler_config).returns({'record_sql' => 'none'})
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_raw
+    self.expects(:sampler_config).returns({'record_sql' => 'raw'})
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :raw, @record_sql, "should be set to :raw, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_falsy
+    self.expects(:sampler_config).returns({'record_sql' => false})
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+  end
+
+  def test_log_sql_transmission_warning_negative
+    log = mocked_log
+    @record_sql = :obfuscated
+    log.expects(:warn).never
+    log_sql_transmission_warning?
+  end
+
+  def test_log_sql_transmission_warning_positive
+    log = mocked_log
+    @record_sql = :raw
+    log.expects(:warn).with('Agent is configured to send raw SQL to the service')
+    log_sql_transmission_warning?
+  end
+
+  def test_sampler_config
+    control = mocked_control
+    control.expects(:fetch).with('transaction_tracer', {})
+    sampler_config
+  end
+
   def test_set_collector_host_positive
     control = mocked_control
     self.expects(:invoke_remote).with(:get_redirect_host).returns('collector-deux.newrelic.com')
@@ -279,9 +365,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
     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)
     finish_setup(config)
     assert_equal 'fishsticks', @agent_id
     assert_equal 'pasta sauce', @report_period
@@ -296,6 +385,12 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     fake_control
   end
 
+  def mocked_log
+    fake_log = mock('log')
+    self.stubs(:log).returns(fake_log)
+    fake_log
+  end
+
   def mocked_error_collector
     fake_collector = mock('error collector')
     self.stubs(:error_collector).returns(fake_collector)