genki-newrelic_rpm 2.10.1

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

@@ -0,0 +1,155 @@
+module NewRelic::Agent
+  class StatsEngine
+        
+    # Defines methods that stub out the stats engine methods
+    # when the agent is disabled
+    
+    class ScopeStackElement
+      attr_reader :name, :deduct_call_time_from_parent
+      attr_accessor :children_time
+      def initialize(name, deduct_call_time)
+        @name = name
+        @deduct_call_time_from_parent = deduct_call_time
+        @children_time = 0
+      end
+    end
+    
+    module Transactions
+      module Shim # :nodoc:
+        def start_transaction; end
+        def end_transaction; end
+        def push_scope(*args); end
+        def pop_scope(*args); end
+      end
+      
+      def transaction_sampler= sampler
+        fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
+        @transaction_sampler = sampler
+      end
+      
+      def remove_transaction_sampler(l)
+        @transaction_sampler = nil
+      end
+      
+      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
+        if @transaction_sampler
+          @transaction_sampler.notice_first_scope_push(time) if stack.empty? 
+          @transaction_sampler.notice_push_scope metric, time
+        end
+        scope = ScopeStackElement.new(metric, deduct_call_time_from_parent)
+        stack.push scope
+        scope
+      end
+      
+      def pop_scope(expected_scope, duration, time=Time.now.to_f)
+        capture_gc_time if collecting_gc?
+        stack = scope_stack
+        scope = stack.pop
+        
+        fail "unbalanced pop from blame stack: #{scope.name} != #{expected_scope.name}" if scope != expected_scope
+        
+        if !stack.empty? 
+          if scope.deduct_call_time_from_parent
+            stack.last.children_time += duration
+          else
+            stack.last.children_time += scope.children_time
+          end
+        end
+        
+        if @transaction_sampler
+          @transaction_sampler.notice_pop_scope(scope.name, time)
+          @transaction_sampler.notice_scope_empty(time) if stack.empty? 
+        end
+        scope
+      end
+      
+      def peek_scope
+        scope_stack.last
+      end
+      
+      # set the name of the transaction for the current thread, which will be used
+      # to define the scope of all traced methods called on this thread until the
+      # scope stack is empty.  
+      #
+      # currently the transaction name is the name of the controller action that 
+      # is invoked via the dispatcher, but conceivably we could use other transaction
+      # names in the future if the traced application does more than service http request
+      # via controller actions
+      def transaction_name=(transaction)
+        Thread::current[:newrelic_transaction_name] = transaction
+      end
+      
+      def transaction_name
+        Thread::current[:newrelic_transaction_name]
+      end
+      
+      def start_transaction
+        Thread::current[:newrelic_scope_stack] = []
+      end
+      
+      # Try to clean up gracefully, otherwise we leave things hanging around on thread locals
+      #
+      def end_transaction
+        stack = scope_stack
+        
+        if stack
+          @transaction_sampler.notice_scope_empty(Time.now) if @transaction_sampler && !stack.empty? 
+          Thread::current[:newrelic_scope_stack] = nil
+        end
+        
+        Thread::current[:newrelic_transaction_name] = nil
+      end
+      
+      private
+      
+      @@collecting_gc = GC.respond_to?(:time) && GC.respond_to?(:collections) 
+      # Make sure we don't do this in a multi-threaded environment
+      def collecting_gc?
+        @@collecting_gc
+      end
+      
+      # smallest recordable amount of GC time. We ignore anything
+      # smaller than this since it's under our reporting thresholds
+      EPSILON = 100 # µs
+      
+      # 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)
+        if num_calls > 0 && elapsed >= EPSILON
+          @last_gc_timestamp += elapsed
+          @last_gc_count += num_calls
+          # µ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, time)
+        end
+      end
+      
+      def scope_stack
+        Thread::current[:newrelic_scope_stack] ||= []
+      end
+      
+    end
+  end
+end

data/lib/new_relic/agent/transaction_sampler.rb

@@ -0,0 +1,319 @@
+
+module NewRelic::Agent
+  
+  class TransactionSampler
+    
+    # Module defining methods stubbed out when the agent is disabled
+    module Shim #:nodoc:
+      def notice_first_scope_push(*args); end
+      def notice_push_scope(*args); end
+      def notice_pop_scope(*args); end
+      def notice_scope_empty(*args); end
+    end
+    
+    BUILDER_KEY = :transaction_sample_builder
+
+    attr_accessor :stack_trace_threshold, :random_sampling, :sampling_rate, :last_sample, :samples
+    
+    def initialize(agent)
+      @samples = []
+      
+      @harvest_count = 0
+      @max_samples = 100
+      @random_sample = nil
+      config = NewRelic::Control.instance
+      sampler_config = config.fetch('transaction_tracer', {})
+      @stack_trace_threshold = sampler_config.fetch('stack_trace_threshold', 0.500).to_f
+      @stats_engine = agent.stats_engine
+      @stats_engine.transaction_sampler = self
+
+      agent.set_sql_obfuscator(:replace) do |sql| 
+        default_sql_obfuscator(sql)
+      end
+      @samples_lock = Mutex.new
+    end
+    
+    def current_sample_id
+      b=builder
+      b and b.sample_id
+    end
+
+    def disable
+      NewRelic::Agent.instance.stats_engine.remove_transaction_sampler self
+    end
+    
+    def sampling_rate=(val)
+      @sampling_rate = val
+      @harvest_count = rand(val)
+    end
+    
+    def default_sql_obfuscator(sql)
+      sql = sql.dup
+      # This is hardly readable.  Use the unit tests.
+      # remove single quoted strings:
+      sql.gsub!(/'(.*?[^\\'])??'(?!')/, '?')
+      # remove double quoted strings:
+      sql.gsub!(/"(.*?[^\\"])??"(?!")/, '?')
+      # replace all number literals
+      sql.gsub!(/\d+/, "?")
+      sql
+    end
+    
+    
+    def notice_first_scope_push(time)
+      if Thread::current[:record_tt] == false || !NewRelic::Agent.is_execution_traced?
+        Thread::current[BUILDER_KEY] = nil
+      else
+        Thread::current[BUILDER_KEY] = TransactionSampleBuilder.new(time)
+      end
+    end
+    
+    def notice_push_scope(scope, time=Time.now.to_f)
+      
+      return unless builder
+      
+      builder.trace_entry(scope, time)
+      
+      # in developer mode, capture the stack trace with the segment.
+      # this is cpu and memory expensive and therefore should not be
+      # turned on in production mode
+      if NewRelic::Control.instance.developer_mode?
+        segment = builder.current_segment
+        if segment
+          # Strip stack frames off the top that match /new_relic/agent/
+          trace = caller
+          while trace.first =~/\/lib\/new_relic\/agent\//
+            trace.shift
+          end
+          
+          trace = trace[0..39] if trace.length > 40
+          segment[:backtrace] = trace
+        end
+      end
+    end
+    
+    def scope_depth
+      return 0 unless builder
+
+      builder.scope_depth
+    end
+  
+    def notice_pop_scope(scope, time = Time.now.to_f)
+      return unless builder
+      builder.trace_exit(scope, time)
+    end
+    
+    # This is called when we are done with the transaction.  We've
+    # unwound the stack to the top level.
+    def notice_scope_empty(time=Time.now.to_f)
+      
+      last_builder = builder
+      return unless last_builder
+
+      last_builder.finish_trace(time)
+      reset_builder
+      
+    
+      @samples_lock.synchronize do
+        @last_sample = last_builder.sample
+        
+        # We sometimes see "unanchored" transaction traces
+        if @last_sample.params[:path]
+          @random_sample = @last_sample if @random_sampling
+                  
+          # ensure we don't collect more than a specified number of samples in memory
+          @samples << @last_sample if NewRelic::Control.instance.developer_mode?
+          @samples.shift while @samples.length > @max_samples
+          
+          if @slowest_sample.nil? || @slowest_sample.duration < @last_sample.duration
+            @slowest_sample = @last_sample
+          end
+        end
+      end
+    end
+    
+    def notice_transaction(path, request, params)
+      return unless builder
+
+      builder.set_transaction_info(path, request, params)
+    end
+    
+    def notice_transaction_cpu_time(cpu_time)
+      return unless builder
+
+      builder.set_transaction_cpu_time(cpu_time)
+    end
+    
+        
+    # some statements (particularly INSERTS with large BLOBS
+    # may be very large; we should trim them to a maximum usable length
+    # config is the driver configuration for the connection
+    MAX_SQL_LENGTH = 16384
+    def notice_sql(sql, config, duration)
+      return unless builder
+      if Thread::current[:record_sql].nil? || Thread::current[:record_sql]
+        segment = builder.current_segment
+        if segment
+          current_sql = segment[:sql]
+          sql = current_sql + ";\n" + sql if current_sql
+
+          if sql.length > (MAX_SQL_LENGTH - 4)
+            sql = sql[0..MAX_SQL_LENGTH-4] + '...'
+          end
+          
+          segment[:sql] = sql
+          segment[:connection_config] = config
+          segment[:backtrace] = caller.join("\n") if duration >= @stack_trace_threshold 
+        end
+      end
+    end
+
+    
+    # get the set of collected samples, merging into previous samples,
+    # and clear the collected sample list. 
+    
+    def harvest(previous = nil, slow_threshold = 2.0)
+      result = []
+      previous ||= []
+      
+      previous = [previous] unless previous.is_a?(Array)
+      
+      previous_slowest = previous.inject(nil) {|a,ts| (a) ? ((a.duration > ts.duration) ? a : ts) : ts}
+      
+      @samples_lock.synchronize do
+        
+        if @random_sampling        
+          @harvest_count += 1
+          
+          if (@harvest_count % @sampling_rate) == 0
+            result << @random_sample if @random_sample
+          else
+            @random_sample = nil   # if we don't nil this out, then we won't send the slowest if slowest == @random_sample
+          end
+        end
+        
+        slowest = @slowest_sample
+        @slowest_sample = nil
+        
+        if slowest && slowest != @random_sample && slowest.duration >= slow_threshold
+          if previous_slowest.nil? || previous_slowest.duration < slowest.duration
+            result << slowest
+          else
+            result << previous_slowest
+          end
+        end
+
+        @random_sample = nil
+        @last_sample = nil
+      end
+      result
+    end
+
+    # reset samples without rebooting the web server
+    def reset!
+      @samples = []
+    end
+
+    private 
+      
+      def builder
+        Thread::current[BUILDER_KEY]
+      end
+      def reset_builder
+        Thread::current[BUILDER_KEY] = nil
+      end
+      
+  end
+
+  # a builder is created with every sampled transaction, to dynamically
+  # generate the sampled data.  It is a thread-local object, and is not
+  # accessed by any other thread so no need for synchronization.
+  class TransactionSampleBuilder
+    attr_reader :current_segment
+    
+    include CollectionHelper
+    
+    def initialize(time=Time.now.to_f)
+      @sample = NewRelic::TransactionSample.new(time)
+      @sample_start = time
+      @current_segment = @sample.root_segment
+    end
+
+    def sample_id
+      @sample.sample_id
+    end
+
+    def trace_entry(metric_name, time)
+      segment = @sample.create_segment(time - @sample_start, metric_name)
+      @current_segment.add_called_segment(segment)
+      @current_segment = segment
+    end
+
+    def trace_exit(metric_name, time)
+      if metric_name != @current_segment.metric_name
+        fail "unbalanced entry/exit: #{metric_name} != #{@current_segment.metric_name}"
+      end
+      @current_segment.end_trace(time - @sample_start)
+      @current_segment = @current_segment.parent_segment
+    end
+    
+    def finish_trace(time)
+      # This should never get called twice, but in a rare case that we can't reproduce in house it does.
+      # log forensics and return gracefully
+      if @sample.frozen?
+        log = NewRelic::Control.instance.log
+        
+        log.warn "Unexpected double-freeze of Transaction Trace Object."
+        log.info "Please send this diagnostic data to New Relic"
+        log.info @sample.to_s
+        return
+      end
+      @sample.root_segment.end_trace(time - @sample_start)
+      @sample.params[:custom_params] = normalize_params(NewRelic::Agent.instance.custom_params) 
+      @sample.freeze
+      @current_segment = nil
+    end
+    
+    def scope_depth
+      depth = -1        # have to account for the root
+      current = @current_segment
+      
+      while(current)
+        depth += 1
+        current = current.parent_segment
+      end
+      
+      depth
+    end
+    
+    def freeze
+      @sample.freeze unless sample.frozen?
+    end
+    
+    
+    def set_transaction_info(path, request, params)
+      @sample.params[:path] = path
+      
+      if NewRelic::Control.instance.capture_params
+        params = normalize_params params
+        
+        @sample.params[:request_params].merge!(params)
+        @sample.params[:request_params].delete :controller
+        @sample.params[:request_params].delete :action
+      end
+      
+      @sample.params[:uri] = request.path if request
+    end
+    
+    def set_transaction_cpu_time(cpu_time)
+      @sample.params[:cpu_time] = cpu_time
+    end
+    
+    
+    def sample
+      fail "Not finished building" unless @sample.frozen?
+      @sample
+    end
+    
+  end
+end