newrelic_rpm 3.1.2 → 3.2.0.beta1

data/lib/new_relic/agent/instrumentation/rails3/active_record_instrumentation.rb

@@ -67,6 +67,7 @@ module NewRelic
                 log_without_newrelic_instrumentation(*args, &block)
               ensure
                 NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, (Time.now - t0).to_f)
+                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric, supported_config, (Time.now - t0).to_f)
               end
             end
           end
@@ -78,12 +79,14 @@ module NewRelic
 end
 
 DependencyDetection.defer do
+  @name = :rails3_active_record
+  
   depends_on do
     defined?(ActiveRecord) && defined?(ActiveRecord::Base)
   end
 
   depends_on do
-    defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
   end
 
   depends_on do
@@ -95,7 +98,7 @@ DependencyDetection.defer do
   end
   
   executes do
-    NewRelic::Agent.logger.debug 'Installing Rails3 ActiveRecord instrumentation'
+    NewRelic::Agent.logger.debug 'Installing Rails 3 ActiveRecord instrumentation'
   end
   
   executes do

data/lib/new_relic/agent/instrumentation/rails3/errors.rb

@@ -15,8 +15,10 @@ module NewRelic
 end
 
 DependencyDetection.defer do
+  @name = :rails3_error
+  
   depends_on do
-    defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i == 3
+    defined?(::Rails) && ::Rails.respond_to?(:version) && ::Rails.version.to_i == 3
   end
 
   depends_on do

data/lib/new_relic/agent/instrumentation/sunspot.rb

@@ -1,4 +1,6 @@
 DependencyDetection.defer do
+  @name = :sunspot
+
   depends_on do
     defined?(::Sunspot)
   end

data/lib/new_relic/agent/instrumentation/unicorn_instrumentation.rb

@@ -1,4 +1,6 @@
 DependencyDetection.defer do
+  @name = :unicorn
+
   depends_on do
     defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
   end
@@ -9,7 +11,6 @@ DependencyDetection.defer do
   
   executes do
     Unicorn::HttpServer.class_eval do
-      NewRelic::Agent.logger.debug "Installing Unicorn worker hook."
       old_worker_loop = instance_method(:worker_loop)
       define_method(:worker_loop) do | worker |
         NewRelic::Agent.after_fork(:force_reconnect => true)

data/lib/new_relic/agent/shim_agent.rb

@@ -12,6 +12,7 @@ module NewRelic
         @stats_engine.extend NewRelic::Agent::StatsEngine::Shim
         @stats_engine.extend NewRelic::Agent::StatsEngine::Transactions::Shim
         @transaction_sampler.extend NewRelic::Agent::TransactionSampler::Shim
+        @sql_sampler.extend NewRelic::Agent::SqlSampler::Shim
         @error_collector.extend NewRelic::Agent::ErrorCollector::Shim
       end
       def after_fork *args; end

data/lib/new_relic/agent/sql_sampler.rb

@@ -0,0 +1,230 @@
+require 'new_relic/agent'
+require 'new_relic/control'
+module NewRelic
+  module Agent
+
+    class SqlSampler
+
+      # Module defining methods stubbed out when the agent is disabled
+      module Shim #:nodoc:
+        def notice_scope_empty(*args); end
+        def notice_first_scope_push(*args); end
+        def notice_transaction(*args); end
+      end
+
+      attr_reader :disabled
+
+      # this is for unit tests only
+      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
+        @sql_traces = {}
+        clear_transaction_data
+
+        # This lock is used to synchronize access to the @last_sample
+        # and related variables. It can become necessary on JRuby or
+        # any 'honest-to-god'-multithreaded system
+        @samples_lock = Mutex.new
+      end
+
+      # Enable the sql sampler - this also registers it with
+      # the statistics engine.
+      def enable
+        @disabled = false
+        NewRelic::Agent.instance.stats_engine.sql_sampler = self
+      end
+
+      # Disable the sql sampler - this also deregisters it
+      # with the statistics engine.
+      def disable
+        @disabled = true
+        NewRelic::Agent.instance.stats_engine.remove_sql_sampler(self)
+      end
+
+      def notice_transaction(path, uri=nil, params={})
+        transaction_data.set_transaction_info(path, uri, params) if !disabled && transaction_data
+      end
+
+      def notice_first_scope_push(time)
+        create_transaction_data
+      end
+
+      def create_transaction_data
+        Thread.current[:new_relic_sql_data] = TransactionSqlData.new
+      end
+
+      def transaction_data
+        Thread.current[:new_relic_sql_data]
+      end
+
+      def clear_transaction_data
+        Thread.current[:new_relic_sql_data] = nil
+      end
+
+      # This is called when we are done with the transaction.
+      def notice_scope_empty(time=Time.now)
+        data = transaction_data
+        clear_transaction_data
+
+        if data.sql_data.count > 0
+          @samples_lock.synchronize do
+            NewRelic::Agent.instance.log.debug "Harvesting #{data.sql_data.count} slow transaction sql statement(s)"
+            #FIXME get tx name and uri
+            harvest_slow_sql data
+          end
+        end
+      end
+
+      # 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]
+          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_item, transaction_sql_data.path, transaction_sql_data.uri)
+          end
+        end
+
+      end
+
+      def notice_sql(sql, metric_name, config, duration)
+        return unless transaction_data
+        if NewRelic::Agent.is_sql_recorded?
+          if duration > @explain_threshold
+            backtrace = caller.join("\n")
+            transaction_data.sql_data << SlowSql.new(sql, metric_name, config,
+                                                     duration, backtrace)
+          end
+        end
+      end
+
+      def merge(sql_traces)
+        @samples_lock.synchronize do
+#FIXME we need to merge the sql_traces array back into the @sql_traces hash
+#          @sql_traces.merge! sql_traces
+        end
+      end
+
+      def harvest
+        return [] if disabled
+        result = []
+        @samples_lock.synchronize do
+          result = @sql_traces.values
+          @sql_traces = {}
+        end        
+        slowest = result.sort{|a,b| b.max_call_time <=> a.max_call_time}[0,10]
+        slowest.each {|trace| trace.prepare_to_send }
+        slowest
+      end
+
+      # reset samples without rebooting the web server
+      def reset!
+      end
+    end
+
+    class TransactionSqlData
+      attr_reader :path
+      attr_reader :uri
+      attr_reader :params
+      attr_reader :sql_data
+
+      def initialize
+        @sql_data = []
+      end
+
+      def set_transaction_info(path, uri, params)
+        @path = path
+        @uri = uri
+        @params = params
+      end
+    end
+
+    class SlowSql
+      attr_reader :sql
+      attr_reader :metric_name
+      attr_reader :duration
+      attr_reader :backtrace
+
+      def initialize(sql, metric_name, config, duration, backtrace = nil)
+        @sql = sql
+        @metric_name = metric_name
+        @config = config
+        @duration = duration
+        @backtrace = backtrace
+      end
+
+      def obfuscate
+        NewRelic::Agent::Database.obfuscate_sql(@sql)
+      end
+
+      def normalize
+        NewRelic::Agent::Database::Obfuscator.instance \
+          .default_sql_obfuscator(@sql).gsub(/\?\s*\,\s*/, '')
+      end
+
+      def explain
+        NewRelic::Agent::Database.explain_sql(@sql, @config)
+      end
+    end
+
+    class SqlTrace < MethodTraceStats
+      attr_reader :path
+      attr_reader :url
+      attr_reader :sql_id
+      attr_reader :sql
+      attr_reader :database_metric_name
+      attr_reader :params
+
+      def initialize(obfuscated_sql, slow_sql, path, uri)
+        super()
+        @params = {} #FIXME
+        @sql_id = obfuscated_sql.hash
+        set_primary slow_sql, path, uri
+        record_data_point slow_sql.duration
+      end
+
+      def set_primary(slow_sql, path, uri)
+        @slow_sql = slow_sql
+        @sql = slow_sql.sql
+        @database_metric_name = slow_sql.metric_name
+        @path = path
+        @url = uri
+        # FIXME
+        @params[:backtrace] = slow_sql.backtrace if slow_sql.backtrace
+      end
+
+      def aggregate(slow_sql, path, uri)
+        if slow_sql.duration > max_call_time
+          set_primary slow_sql, path, uri
+        end
+
+        record_data_point slow_sql.duration
+      end
+      
+      def prepare_to_send
+        begin
+          params[:explain_plan] = @slow_sql.explain
+        ensure
+          NewRelic::Agent::Database.close_connections
+        end
+        @sql = @slow_sql.obfuscate if need_to_obfuscate?
+      end
+
+      def need_to_obfuscate?
+        NewRelic::Control.instance['transaction_tracer']['record_sql'] == 'obfuscated'
+      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
+    end
+  end
+end

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

@@ -25,6 +25,7 @@ module Agent
         def end_transaction; end
         def push_scope(*args); end
         def transaction_sampler=(*args); end
+        def sql_sampler=(*args); end
         def scope_name=(*args); end
         def scope_name; end
         def pop_scope(*args); end
@@ -42,6 +43,15 @@ module Agent
         @transaction_sampler = nil
       end
       
+      def sql_sampler= sampler
+        fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
+        @sql_sampler = sampler
+      end
+
+      def remove_sql_sampler(l)
+        @sql_sampler = nil
+      end
+
       # Pushes a scope onto the transaction stack - this generates a
       # TransactionSample::Segment at the end of transaction execution
       def push_scope(metric, time = Time.now.to_f, deduct_call_time_from_parent = true)

data/lib/new_relic/agent/transaction_sampler.rb

@@ -32,7 +32,15 @@ module NewRelic
         @harvest_count = 0
         @random_sample = nil
         @sampling_rate = 10
+        configure!
 
+        # This lock is used to synchronize access to the @last_sample
+        # and related variables. It can become necessary on JRuby or
+        # any 'honest-to-god'-multithreaded system
+        @samples_lock = Mutex.new
+      end
+
+      def configure!
         # @segment_limit and @stack_trace_threshold come from the
         # configuration file, with built-in defaults that should
         # suffice for most customers
@@ -40,11 +48,7 @@ module NewRelic
         sampler_config = config.fetch('transaction_tracer', {})
         @segment_limit = sampler_config.fetch('limit_segments', 4000)
         @stack_trace_threshold = sampler_config.fetch('stack_trace_threshold', 0.500).to_f
-
-        # This lock is used to synchronize access to the @last_sample
-        # and related variables. It can become necessary on JRuby or
-        # any 'honest-to-god'-multithreaded system
-        @samples_lock = Mutex.new
+        @explain_threshold = sampler_config.fetch('explain_threshold', 0.5).to_f
       end
 
       # Returns the current sample id, delegated from `builder`
@@ -236,7 +240,8 @@ module NewRelic
         return unless builder
         segment = builder.current_segment
         if segment
-          segment[key] = truncate_message(append_new_message(segment[key], message))
+          segment[key] = truncate_message(append_new_message(segment[key],
+                                                             message))
           segment[config_key] = config if config_key
           append_backtrace(segment, duration)
         end

data/lib/new_relic/collection_helper.rb

@@ -2,8 +2,8 @@ require 'new_relic/control'
 
 module NewRelic
   module CollectionHelper
-  DEFAULT_TRUNCATION_SIZE=256
-  DEFAULT_ARRAY_TRUNCATION_SIZE=1024
+  DEFAULT_TRUNCATION_SIZE=16 * 1024
+  DEFAULT_ARRAY_TRUNCATION_SIZE=128
   # Transform parameter hash into a hash whose values are strictly
   # strings
   def normalize_params(params)
@@ -17,7 +17,7 @@ module NewRelic
       when Hash
         new_params = {}
         params.each do | key, value |
-          new_params[truncate(normalize_params(key),32)] = normalize_params(value)
+          new_params[truncate(normalize_params(key),64)] = normalize_params(value)
         end
         new_params
       when Array
@@ -35,7 +35,10 @@ module NewRelic
       # this is for 1.9.1, where strings no longer have Enumerable
       backtrace = backtrace.split("\n") if String === backtrace
       backtrace = backtrace.map &:to_s
-      backtrace = backtrace.reject {|line| line.include?(NewRelic::Control.newrelic_root) }
+      backtrace = backtrace.reject do |line|
+        line.include?(NewRelic::Control.newrelic_root) or
+        line =~ /^newrelic_rpm\s/
+      end
       # rename methods back to their original state
       backtrace = backtrace.collect {|line| line.gsub(/_without_(newrelic|trace)/, "")}
     end

data/lib/new_relic/commands/deployments.rb

@@ -17,7 +17,7 @@ class NewRelic::Command::Deployments < NewRelic::Command
   # Initialize the deployment uploader with command line args.
   # Use -h to see options.
   # When command_line_args is a hash, we are invoking directly and
-  # it's treated as an options with optional sttring values for
+  # it's treated as an options with optional string values for
   # :user, :description, :appname, :revision, :environment,
   # and :changes.
   #

data/lib/new_relic/commands/install.rb

@@ -52,21 +52,10 @@ at www.newrelic.com, and replace the newrelic.yml file with the one
 you receive upon registration.
     EOF
     puts <<-EOF unless quiet
-
+    
 E-mail support@newrelic.com with any problems or questions.
-
-    EOF
-    puts <<-EOF
-
-Installing the plugin from Rubyforge is deprecated. This repository will not be updated after January 2011
-
-Please use one of the following options:
-
-Gems: gem install newrelic_rpm
-
-Github! git clone git://github.com/newrelic/rpm.git vendor/plugins/newrelic_rpm
-
     EOF
+    
   end
 
   def content

data/lib/new_relic/control/class_methods.rb

@@ -3,9 +3,10 @@ module NewRelic
     # class-level methods for lazy creation of NewRelic::Control and
     # NewRelic::LocalEnvironment instances.
     module ClassMethods
-      # Access the Control singleton, lazy initialized
-      def instance
-        @instance ||= new_instance
+      # Access the Control singleton, lazy initialized.  Default will instantiate a new
+      # instance or pass false to defer
+      def instance(create=true)
+        @instance ||= create && new_instance
       end
       
       # Access the LocalEnvironment singleton, lazy initialized