newrelic_rpm 3.2.0.1 → 3.3.0.beta1

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

@@ -19,12 +19,6 @@ module NewRelic
 
           sql, name, binds = args
 
-          # Capture db config if we are going to try to get the explain plans
-          if (defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)) ||
-              (defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter) && self.is_a?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)) ||
-              (defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter))
-            supported_config = @config
-          end
           if name && (parts = name.split " ") && parts.size == 2
             model = parts.first
             operation = parts.last.downcase
@@ -60,14 +54,22 @@ module NewRelic
           else
             metrics = [metric, "ActiveRecord/all"]
             metrics << "ActiveRecord/#{metric_name}" if metric_name
+            if NewRelic::Agent::Database.config && NewRelic::Agent::Database.config[:adapter]
+              type = NewRelic::Agent::Database.config[:adapter].sub(/\d*/, '')
+              host = NewRelic::Agent::Database.config[:host] || 'localhost'
+              metrics << "RemoteService/sql/#{type}/#{host}"
+            end            
+            
             self.class.trace_execution_scoped(metrics) do
               sql, name, binds = args
               t0 = Time.now
               begin
                 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)
+                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, NewRelic::Agent::Database.config,
+                                                                        (Time.now - t0).to_f)
+                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric, NewRelic::Agent::Database.config,
+                                                                (Time.now - t0).to_f)
               end
             end
           end
@@ -112,6 +114,7 @@ DependencyDetection.defer do
   executes do
     Rails.configuration.after_initialize do
       ActiveRecord::Base.class_eval do
+        NewRelic::Agent::Database::ConnectionManager.instance.config = connection.instance_eval{ @config }
         class << self
           add_method_tracer :find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql', :metric => false
           add_method_tracer :transaction, 'ActiveRecord/#{self.name}/transaction', :metric => false

data/lib/new_relic/agent/sql_sampler.rb

@@ -33,6 +33,15 @@ module NewRelic
         @explain_enabled = config.fetch('explain_enabled', true)
         @stack_trace_threshold = config.fetch('stack_trace_threshold',
                                               0.5).to_f
+        if config.fetch('enabled', true) &&
+            NewRelic::Control.instance['transaction_tracer'] &&
+            NewRelic::Control.instance['transaction_tracer'].fetch('enabled',
+                                                                   true) &&
+            NewRelic::Control.instance.fetch('collect_traces', true)
+          enable
+        else
+          disable
+        end
       end
 
       def config
@@ -45,14 +54,12 @@ module NewRelic
       # 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 enabled?
@@ -60,7 +67,10 @@ module NewRelic
       end
 
       def notice_transaction(path, uri=nil, params={})
-        transaction_data.set_transaction_info(path, uri, params) if !disabled && transaction_data
+        if NewRelic::Agent.instance.transaction_sampler.builder
+          guid = NewRelic::Agent.instance.transaction_sampler.builder.sample.guid
+        end
+        transaction_data.set_transaction_info(path, uri, params, guid) if !disabled && transaction_data
       end
 
       def notice_first_scope_push(time)
@@ -149,15 +159,17 @@ module NewRelic
       attr_reader :uri
       attr_reader :params
       attr_reader :sql_data
+      attr_reader :guid
 
       def initialize
         @sql_data = []
       end
 
-      def set_transaction_info(path, uri, params)
+      def set_transaction_info(path, uri, params, guid)
         @path = path
         @uri = uri
         @params = params
+        @guid = guid
       end
     end
 
@@ -255,12 +267,12 @@ module NewRelic
       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)
+          Digest::MD5.hexdigest(string).hex
         else
           string.hash
-        end
+        end.modulo(2**31-1)
+        # modulo ensures sql_id fits in an INT(11)
       end
     end
   end

data/lib/new_relic/agent/stats_engine.rb

@@ -1,6 +1,7 @@
 require 'new_relic/agent/stats_engine/metric_stats'
 require 'new_relic/agent/stats_engine/samplers'
 require 'new_relic/agent/stats_engine/transactions'
+require 'new_relic/agent/stats_engine/gc_profiler'
 
 module NewRelic
   module Agent

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

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+module NewRelic
+  module Agent
+    class StatsEngine
+      module GCProfiler
+        def self.init
+          @profiler = RailsBench.new if RailsBench.enabled?
+          @profiler = Ruby19.new if Ruby19.enabled?
+          @profiler = Rubinius.new if Rubinius.enabled?
+        end
+
+        def self.capture
+          @profiler.capture if @profiler
+        end
+        
+        class Profiler
+          def initialize
+            if self.class.enabled?
+              @last_timestamp = call_time
+              @last_count = call_count
+            end
+          end
+          
+          def capture
+            return unless self.class.enabled?
+            return if !scope_stack.empty? && scope_stack.last.name == "GC/cumulative"
+            
+            num_calls = call_count - @last_count
+            elapsed = (call_time - @last_timestamp).to_f
+            @last_timestamp = call_time
+            @last_count = call_count
+            reset
+            
+            record_gc_metric(num_calls, elapsed)
+          end
+
+          def reset; end
+          
+          protected
+                    
+          def record_gc_metric(num_calls, elapsed)
+            if num_calls > 0
+              # µs to seconds
+              elapsed = elapsed / 1_000_000.0
+              # Allocate the GC time to a scope as if the GC just ended
+              # right now.
+              time = Time.now.to_f
+              gc_scope = NewRelic::Agent.instance.stats_engine.push_scope("GC/cumulative", time - elapsed)
+              # GC stats are collected into a blamed metric which allows
+              # us to show the stats controller by controller
+              gc_stats = NewRelic::Agent.get_stats(gc_scope.name, true)
+              gc_stats.record_multiple_data_points(elapsed, num_calls)
+              NewRelic::Agent.instance.stats_engine.pop_scope(gc_scope, elapsed, time)
+            end
+          end
+
+          def scope_stack
+            Thread::current[:newrelic_scope_stack] ||= []
+          end        
+        end
+        
+        class RailsBench < Profiler
+          def self.enabled?
+            ::GC.respond_to?(:time) && ::GC.respond_to?(:collections)
+          end
+          
+          def call_time
+            ::GC.time
+          end
+          
+          def call_count
+            ::GC.collections
+          end
+        end
+        
+        class Ruby19 < Profiler
+          def self.enabled?
+            defined?(::GC::Profiler) && ::GC::Profiler.enabled?
+          end
+          
+          def call_time
+            ::GC::Profiler.total_time * 1000.0
+          end
+          
+          def call_count
+            ::GC.count
+          end
+          
+          def reset
+            ::GC::Profiler.clear
+            @last_timestamp = 0
+          end
+        end
+
+        class Rubinius < Profiler
+          def self.enabled?
+            if NewRelic::LanguageSupport.using_engine?('rbx')
+              require 'rubinius/agent'
+              true
+            else
+              false
+            end
+          end
+
+          def call_time
+            agent = ::Rubinius::Agent.loopback
+            (agent.get('system.gc.young.total_wallclock')[1] +
+              agent.get('system.gc.full.total_wallclock')[1]) * 1000
+          end
+
+          def call_count
+            agent = ::Rubinius::Agent.loopback
+            agent.get('system.gc.young.count')[1] +
+              agent.get('system.gc.full.count')[1]
+          end          
+        end
+      end
+    end
+  end
+end

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

@@ -25,7 +25,6 @@ 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
@@ -43,29 +42,11 @@ 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)
-
         stack = scope_stack
-        if collecting_gc?
-          if stack.empty?
-            # reset the gc time so we only include gc time spent during this call
-            @last_gc_timestamp = gc_time
-            @last_gc_count = gc_collections
-          else
-            capture_gc_time
-          end
-        end
+        stack.empty? ? GCProfiler.init : GCProfiler.capture
         @transaction_sampler.notice_push_scope metric, time if @transaction_sampler
         scope = ScopeStackElement.new(metric, deduct_call_time_from_parent)
         stack.push scope
@@ -75,7 +56,7 @@ module Agent
       # Pops a scope off the transaction stack - this updates the
       # transaction sampler that we've finished execution of a traced method
       def pop_scope(expected_scope, duration, time=Time.now.to_f)
-        capture_gc_time if collecting_gc?
+        GCProfiler.capture
         stack = scope_stack
         scope = stack.pop
         fail "unbalanced pop from blame stack, got #{scope ? scope.name : 'nil'}, expected #{expected_scope ? expected_scope.name : 'nil'}" if scope != expected_scope
@@ -106,7 +87,6 @@ module Agent
       # via controller actions
       def scope_name=(transaction)
         Thread::current[:newrelic_scope_name] = transaction
-        Thread::current[:newrelic_most_recent_transaction] = transaction
       end
       
       # Returns the current scope name from the thread local
@@ -134,74 +114,11 @@ module Agent
       end
 
       private
-
-      # Make sure we don't do this in a multi-threaded environment
-      def collecting_gc?
-        if !defined?(@@collecting_gc)
-          @@collecting_gc = false
-          if !NewRelic::Control.instance.multi_threaded?
-            @@collecting_gc = true if GC.respond_to?(:time) && GC.respond_to?(:collections) # 1.8.x
-            @@collecting_gc = true if defined?(GC::Profiler) && GC::Profiler.enabled? # 1.9.2
-          end
-        end
-        @@collecting_gc
-      end
-
-      # The total number of times the garbage collector has run since
-      # profiling was enabled
-      def gc_collections
-        if GC.respond_to?(:count)
-          GC.count
-        elsif GC.respond_to?(:collections)
-          GC.collections
-        end
-      end
-
-      # The total amount of time taken by garbage collection since
-      # profiling was enabled
-      def gc_time
-        if GC.respond_to?(:time)
-          GC.time
-        elsif defined?(GC::Profiler) && GC::Profiler.respond_to?(:total_time)
-          # The 1.9 profiler returns a time in usec
-          GC::Profiler.total_time * 1000000.0
-        end
-      end
-
-      # Assumes collecting_gc?
-      def capture_gc_time
-        # Skip this if we are already in this segment
-        return if !scope_stack.empty? && scope_stack.last.name == "GC/cumulative"
-        num_calls = gc_collections - @last_gc_count
-        elapsed = (gc_time - @last_gc_timestamp).to_f
-        @last_gc_timestamp = gc_time
-        @last_gc_count = gc_collections
-        
-        if defined?(GC::Profiler)
-          GC::Profiler.clear
-          @last_gc_timestamp = 0
-        end
-        
-        if num_calls > 0
-          # µs to seconds
-          elapsed = elapsed / 1000000.0
-          # Allocate the GC time to a scope as if the GC just ended
-          # right now.
-          time = Time.now.to_f
-          gc_scope = push_scope("GC/cumulative", time - elapsed)
-          # GC stats are collected into a blamed metric which allows
-          # us to show the stats controller by controller
-          gc_stats = NewRelic::Agent.get_stats(gc_scope.name, true)
-          gc_stats.record_multiple_data_points(elapsed, num_calls)
-          pop_scope(gc_scope, elapsed, time)
-        end
-      end
       
       # Returns the current scope stack, memoized to a thread local variable
       def scope_stack
         Thread::current[:newrelic_scope_stack] ||= []
       end
-
     end
   end
 end

data/lib/new_relic/agent/transaction_info.rb

@@ -0,0 +1,49 @@
+module NewRelic
+  module Agent
+    class TransactionInfo
+      
+      attr_accessor :token, :capture_deep_tt, :transaction_name
+      attr_reader :start_time
+      
+      def initialize
+        @guid = ""
+        @transaction_name = "(unknown)"
+        @start_time = Time.now
+      end
+      
+      def force_persist_sample?(sample)
+        token && sample.duration > NewRelic::Control.instance.apdex_t
+      end
+      
+      def include_guid?
+        token && duration > NewRelic::Control.instance.apdex_t
+      end
+      
+      def guid
+        @guid
+      end
+      
+      def guid=(value)
+        @guid = value
+      end
+      
+      def duration
+        Time.now - start_time
+      end
+      
+      def self.get()
+        Thread.current[:newrelic_transaction_info] ||= TransactionInfo.new
+      end
+      
+      def self.set(instance)
+        Thread.current[:newrelic_transaction_info] = instance
+      end
+      
+      def self.clear
+        Thread.current[:newrelic_transaction_info] = nil
+      end
+      
+    end
+  end
+end
+

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -51,6 +51,8 @@ module NewRelic
         end
         @sample.root_segment.end_trace(time.to_f - @sample_start)
         @sample.params[:custom_params] = normalize_params(NewRelic::Agent::Instrumentation::MetricFrame.custom_parameters)
+        
+        @sample.force_persist = NewRelic::Agent::TransactionInfo.get.force_persist_sample?(sample)
         @sample.freeze
         @current_segment = nil
       end

data/lib/new_relic/agent/transaction_sampler.rb

@@ -20,12 +20,14 @@ module NewRelic
 
       attr_accessor :stack_trace_threshold, :random_sampling, :sampling_rate
       attr_accessor :explain_threshold, :explain_enabled, :transaction_threshold
+      attr_accessor :slow_capture_threshold
       attr_reader :samples, :last_sample, :disabled
 
       def initialize
         # @samples is an array of recent samples up to @max_samples in
         # size - it's only used by developer mode
         @samples = []
+        @force_persist = []
         @max_samples = 100
 
         # @harvest_count is a count of harvests used for random
@@ -33,6 +35,7 @@ module NewRelic
         @harvest_count = 0
         @random_sample = nil
         @sampling_rate = 10
+        @slow_capture_threshold = 2.0
         configure!
 
         # This lock is used to synchronize access to the @last_sample
@@ -179,6 +182,10 @@ module NewRelic
         store_random_sample(sample)
         store_sample_for_developer_mode(sample)
         store_slowest_sample(sample)
+        
+        if NewRelic::Agent::TransactionInfo.get.force_persist_sample?(sample)
+          store_force_persist(sample)
+        end
       end
 
       # Only active when random sampling is true - this is very rarely
@@ -189,6 +196,16 @@ module NewRelic
           @random_sample = sample
         end
       end
+      
+      def store_force_persist(sample)
+        @force_persist << sample
+
+        # WARNING - this clamp should be configurable
+        if @force_persist.length > 15
+          @force_persist.sort! {|a,b| b.duration <=> a.duration}
+          @force_persist = @force_persist[0..14]
+        end
+      end
 
       # Samples take up a ton of memory, so we only store a lot of
       # them in developer mode - we truncate to @max_samples
@@ -202,7 +219,9 @@ module NewRelic
       # Sets @slowest_sample to the passed in sample if it is slower
       # than the current sample in @slowest_sample
       def store_slowest_sample(sample)
-        @slowest_sample = sample if slowest_sample?(@slowest_sample, sample)
+        if slowest_sample?(@slowest_sample, sample)
+          @slowest_sample = sample
+        end
       end
 
       # Checks to see if the old sample exists, or if it's duration is
@@ -285,7 +304,7 @@ module NewRelic
       # Appends a backtrace to a segment if that segment took longer
       # than the specified duration
       def append_backtrace(segment, duration)
-        segment[:backtrace] = caller.join("\n") if duration >= @stack_trace_threshold
+        segment[:backtrace] = caller.join("\n") if (duration >= @stack_trace_threshold || Thread.current[:capture_deep_tt])
       end
 
       # some statements (particularly INSERTS with large BLOBS
@@ -318,23 +337,40 @@ module NewRelic
         if (@harvest_count.to_i % @sampling_rate.to_i) == 0
           result << @random_sample if @random_sample
         end
-        result.uniq!
         nil # don't assume this method returns anything
       end
+      
+      def add_force_persist_to(result)
+        result.concat(@force_persist)
+        @force_persist = []
+      end
 
       # Returns an array of slow samples, with either one or two
       # elements - one element unless random sampling is enabled. The
       # sample returned will be the slowest sample among those
       # available during this harvest
       def add_samples_to(result, slow_threshold)
+        
+        # pull out force persist
+        force_persist = result.select {|sample| sample.force_persist} || []
+        result.reject! {|sample| sample.force_persist}
+        
+        force_persist.each {|sample| store_force_persist(sample)}
+        
+        
+        # Now get the slowest sample
         if @slowest_sample && @slowest_sample.duration >= slow_threshold
           result << @slowest_sample
         end
+
         result.compact!
         result = result.sort_by { |x| x.duration }
-        result = result[-1..-1] || []
+        result = result[-1..-1] || []               # take the slowest sample
+        
         add_random_sample_to(result)
-        result
+        add_force_persist_to(result)
+        
+        result.uniq
       end
 
       # get the set of collected samples, merging into previous samples,
@@ -344,18 +380,42 @@ module NewRelic
       def harvest(previous = [], slow_threshold = 2.0)
         return [] if disabled
         result = Array(previous)
+        
         @samples_lock.synchronize do
           result = add_samples_to(result, slow_threshold)
+                    
           # clear previous transaction samples
           @slowest_sample = nil
           @random_sample = nil
           @last_sample = nil
         end
+        
+        # Clamp the number of TTs we'll keep in memory and send
+        #
+        result = clamp_number_tts(result, 20) if result.length > 20
+        
         # Truncate the samples at 2100 segments. The UI will clamp them at 2000 segments anyway.
         # This will save us memory and bandwidth.
         result.each { |sample| sample.truncate(@segment_limit) }
         result
       end
+      
+      # JON - THIS CODE NEEDS A UNIT TEST
+      def clamp_number_tts(tts, limit)
+        tts.sort! do |a,b|
+          if a.force_persist && b.force_persist
+            b.duration <=> a.duration
+          elsif a.force_persist
+            -1
+          elsif b.force_persist
+            1
+          else
+            b.duration <=> a.duration
+          end
+        end        
+        
+        tts[0..(limit-1)]  
+      end
 
       # reset samples without rebooting the web server
       def reset!
@@ -365,8 +425,6 @@ module NewRelic
         @slowest_sample = nil
       end
 
-      private
-
       # Checks to see if the transaction sampler is disabled, if
       # transaction trace recording is disabled by a thread local, or
       # if execution is untraced - if so it clears the transaction