dolores_rpm 3.2.0.6 → 3.3.4.fork

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

@@ -0,0 +1,123 @@
+# -*- 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
+              # microseconds 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
+          
+          # microseconds spent in GC
+          def call_time
+            ::GC.time # this should already be microseconds
+          end
+          
+          def call_count
+            ::GC.collections
+          end
+        end
+        
+        class Ruby19 < Profiler
+          def self.enabled?
+            defined?(::GC::Profiler) && ::GC::Profiler.enabled?
+          end
+          
+          # microseconds spent in GC
+          # 1.9 total_time returns seconds.  Don't trust the docs.  It's seconds.
+          def call_time
+            ::GC::Profiler.total_time * 1_000_000.0 # convert seconds to microseconds
+          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/samplers.rb

@@ -74,7 +74,7 @@ module Agent
           begin
             sampled_item.poll
             false # it's okay.  don't delete it.
-          rescue Exception => e
+          rescue => e
             log.error "Removing #{sampled_item} from list"
             log.error e
             log.debug e.backtrace.to_s

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/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/transaction_info.rb

@@ -0,0 +1,74 @@
+require 'erb'
+
+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
+
+      # clears any existing transaction info object and initializes a new one.
+      # This starts the timer for the transaction.
+      def self.reset(request=nil)
+        clear
+        instance = get
+        instance.token = get_token(request)
+      end
+
+      def self.get_token(request)
+        return nil unless request
+        
+        agent_flag = request.cookies['NRAGENT']
+        if agent_flag
+          s = agent_flag.split("=")
+          if s.length == 2
+            if s[0] == "tk" && s[1]
+              ERB::Util.h(s[1])
+            end
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -9,6 +9,7 @@ module NewRelic
     # accessed by any other thread so no need for synchronization.
     class TransactionSampleBuilder
       attr_reader :current_segment, :sample
+      attr_accessor :segment_limit
 
       include NewRelic::CollectionHelper
 
@@ -16,24 +17,35 @@ module NewRelic
         @sample = NewRelic::TransactionSample.new(time.to_f)
         @sample_start = time.to_f
         @current_segment = @sample.root_segment
+        @segment_limit = NewRelic::Control.instance.fetch('transaction_tracer', {}) \
+          .fetch('limit_segments', 4000)
       end
 
       def sample_id
         @sample.sample_id
       end
+      
       def ignored?
         @ignore || @sample.params[:path].nil?
       end
+      
       def ignore_transaction
         @ignore = true
       end
+      
       def trace_entry(metric_name, time)
-        segment = @sample.create_segment(time.to_f - @sample_start, metric_name)
-        @current_segment.add_called_segment(segment)
-        @current_segment = segment
+        if @sample.count_segments < @segment_limit
+          segment = @sample.create_segment(time.to_f - @sample_start, metric_name)
+          @current_segment.add_called_segment(segment)
+          @current_segment = segment
+          if @sample.count_segments == @segment_limit
+            NewRelic::Control.instance.log.debug("Segment limit of #{@segment_limit} reached, ceasing collection.")
+          end
+        end
       end
 
       def trace_exit(metric_name, time)
+        return unless @sample.count_segments < @segment_limit
         if metric_name != @current_segment.metric_name
           fail "unbalanced entry/exit: #{metric_name} != #{@current_segment.metric_name}"
         end
@@ -51,6 +63,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

@@ -1,9 +1,10 @@
 require 'new_relic/agent'
 require 'new_relic/control'
 require 'new_relic/agent/transaction_sample_builder'
+
 module NewRelic
   module Agent
-    
+
     # This class contains the logic of sampling a transaction -
     # creation and modification of transaction samples
     class TransactionSampler
@@ -20,12 +21,15 @@ 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 +37,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
@@ -45,14 +50,20 @@ module NewRelic
         # @segment_limit and @stack_trace_threshold come from the
         # configuration file, with built-in defaults that should
         # suffice for most customers
-        
+
         # enable if config.fetch('enabled', true)
-        
+
         @segment_limit = config.fetch('limit_segments', 4000)
         @stack_trace_threshold = config.fetch('stack_trace_threshold', 0.500).to_f
         @explain_threshold = config.fetch('explain_threshold', 0.5).to_f
         @explain_enabled = config.fetch('explain_enabled', true)
         @transaction_threshold = config.fetch('transation_threshold', 2.0)
+
+        # Configure the sample storage policy.  Create a list of methods to be called.
+        @store_sampler_methods = [ :store_random_sample, :store_slowest_sample ]
+        if NewRelic::Control.instance.developer_mode?
+          @store_sampler_methods << :store_sample_for_developer_mode
+        end
       end
 
       def config
@@ -176,9 +187,11 @@ module NewRelic
       # @samples array, and the @slowest_sample variable if it is
       # slower than the current occupant of that slot
       def store_sample(sample)
-        store_random_sample(sample)
-        store_sample_for_developer_mode(sample)
-        store_slowest_sample(sample)
+        @store_sampler_methods.each{|sym| send sym, 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
@@ -190,6 +203,16 @@ module NewRelic
         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
       def store_sample_for_developer_mode(sample)
@@ -202,7 +225,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
@@ -252,8 +277,14 @@ module NewRelic
         return unless builder
         segment = builder.current_segment
         if segment
-          segment[key] = truncate_message(append_new_message(segment[key],
-                                                             message))
+          new_message = truncate_message(append_new_message(segment[key],
+                                                            message))
+          if key == :sql && config.respond_to?(:has_key?) && config.has_key?(:adapter)
+            segment[key] = Database::Statement.new(new_message)
+            segment[key].adapter = config[:adapter]
+          else
+            segment[key] = new_message
+          end
           segment[config_key] = config if config_key
           append_backtrace(segment, duration)
         end
@@ -285,7 +316,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
@@ -317,24 +348,42 @@ module NewRelic
         @harvest_count += 1
         if (@harvest_count.to_i % @sampling_rate.to_i) == 0
           result << @random_sample if @random_sample
+          @harvest_count = 0
         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,19 +393,43 @@ 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!
         @samples = []
@@ -365,8 +438,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

data/lib/new_relic/agent/worker_loop.rb

@@ -74,7 +74,7 @@ module NewRelic
           # Want to ignore these because they are handled already
         rescue SystemExit, NoMemoryError, SignalException
           raise
-        rescue Exception => e
+        rescue => e
           # Don't blow out the stack for anything that hasn't already propagated
           log.error "Error running task in Agent Worker Loop '#{e}': #{e.backtrace.first}"
           log.debug e.backtrace.join("\n")

data/lib/new_relic/agent.rb

@@ -86,6 +86,7 @@ module NewRelic
     require 'new_relic/agent/busy_calculator'
     require 'new_relic/agent/sampler'
     require 'new_relic/agent/database'
+    require 'new_relic/agent/transaction_info'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -123,8 +124,7 @@ module NewRelic
 
     # The singleton Agent instance.  Used internally.
     def agent #:nodoc:
-      raise "Plugin not initialized!" if @agent.nil?
-      @agent
+      @agent || raise("Plugin not initialized!")
     end
 
     def agent=(new_instance)#:nodoc:
@@ -387,6 +387,19 @@ module NewRelic
     def add_custom_parameters(params)
       NewRelic::Agent::Instrumentation::MetricFrame.add_custom_parameters(params)
     end
+    
+    # Set attributes about the user making this request. These attributes will be automatically
+    # appended to any Transaction Trace or Error that is collected. These attributes
+    # will also be collected for RUM requests.
+    #
+    # Attributes (hash)
+    # * <tt>:user</tt> => user name or ID
+    # * <tt>:account</tt> => account name or ID
+    # * <tt>:product</tt> => product name or level
+    #
+    def set_user_attributes(attributes)
+      NewRelic::Agent::Instrumentation::MetricFrame.set_user_attributes(attributes)
+    end
 
     # The #add_request_parameters method is aliased to #add_custom_parameters
     # and is now deprecated.