newrelic_rpm 2.13.0.beta5 → 2.13.1

data/lib/new_relic/transaction_sample.rb

@@ -1,7 +1,7 @@
 
 module NewRelic
   COLLAPSE_SEGMENTS_THRESHOLD = 2
-  
+
   MYSQL_EXPLAIN_COLUMNS = [
         "Id",
         "Select Type",
@@ -14,44 +14,44 @@ module NewRelic
         "Rows",
         "Extra"
       ].freeze
-  
+
   class TransactionSample
-    
+
     attr_accessor :params, :root_segment
     EMPTY_ARRAY = [].freeze
-    
+
     @@start_time = Time.now
 
     include TransactionAnalysis
     class Segment
       attr_reader :entry_timestamp
-      # The exit timestamp will be relative except for the outermost sample which will 
+      # The exit timestamp will be relative except for the outermost sample which will
       # have a timestamp.
       attr_reader :exit_timestamp
       attr_reader :parent_segment
       attr_reader :metric_name
       attr_reader :segment_id
-      
+
       def initialize(timestamp, metric_name, segment_id)
         @entry_timestamp = timestamp
         @metric_name = metric_name || '<unknown>'
         @segment_id = segment_id || object_id
       end
-      
+
       def end_trace(timestamp)
         @exit_timestamp = timestamp
       end
-      
+
       def add_called_segment(s)
         @called_segments ||= []
         @called_segments << s
         s.parent_segment = self
       end
-      
+
       def to_s
         to_debug_str(0)
       end
-      
+
       def to_json
         map = {:entry_timestamp => @entry_timestamp,
           :exit_timestamp => @exit_timestamp,
@@ -65,7 +65,7 @@ module NewRelic
         end
         map.to_json
       end
-      
+
       def path_string
         "#{metric_name}[#{called_segments.collect {|segment| segment.path_string }.join('')}]"
       end
@@ -78,7 +78,7 @@ module NewRelic
         str
       end
       def to_debug_str(depth)
-        tab = "  " * depth 
+        tab = "  " * depth
         s = tab.clone
         s << ">> #{'%3i ms' % (@entry_timestamp*1000)} [#{self.class.name.split("::").last}] #{metric_name} \n"
         unless params.empty?
@@ -97,21 +97,21 @@ module NewRelic
         end
         s << " #{metric_name}\n"
       end
-      
+
       def called_segments
         @called_segments || EMPTY_ARRAY
       end
-      
+
       # return the total duration of this segment
       def duration
         (@exit_timestamp - @entry_timestamp).to_f
       end
-      
-      # return the duration of this segment without 
+
+      # return the duration of this segment without
       # including the time in the called segments
       def exclusive_duration
         d = duration
-        
+
         if @called_segments
           @called_segments.each do |segment|
             d -= segment.duration
@@ -146,27 +146,27 @@ module NewRelic
         # bandwidth etc as most segments have no parameters
         params[key] = value
       end
-        
+
       def [](key)
         params[key]
       end
-      
+
       def params
         @params ||= {}
       end
-      
-      # call the provided block for this segment and each 
+
+      # call the provided block for this segment and each
       # of the called segments
       def each_segment(&block)
         block.call self
-        
+
         if @called_segments
           @called_segments.each do |segment|
             segment.each_segment(&block)
           end
         end
       end
-      
+
       def find_segment(id)
         return self if @segment_id == id
         called_segments.each do |segment|
@@ -175,14 +175,14 @@ module NewRelic
         end
         nil
       end
-      
+
       # perform this in the runtime environment of a managed application, to explain the sql
       # statement(s) executed within a segment of a transaction sample.
-      # returns an array of explanations (which is an array rows consisting of 
+      # 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 RPM
-      def explain_sql        
+      def explain_sql
         sql = params[:sql]
         return nil unless sql && params[:connection_config]
         statements = sql.split(";\n")
@@ -191,7 +191,7 @@ module NewRelic
           if statement.split($;, 2)[0].upcase == 'SELECT'
             explain_resultset = []
             begin
-              connection = NewRelic::TransactionSample.get_connection(params[:connection_config])    
+              connection = NewRelic::TransactionSample.get_connection(params[:connection_config])
               if connection
                 # 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
@@ -224,7 +224,7 @@ module NewRelic
       def params=(p)
         @params = p
       end
-        
+
 
       def handle_exception_in_explain(e)
         x = 1 # this is here so that code coverage knows we've entered this block
@@ -235,11 +235,11 @@ module NewRelic
       def obfuscated_sql
         TransactionSample.obfuscate_sql(params[:sql])
       end
-      
+
       def called_segments=(segments)
         @called_segments = segments
       end
-      
+
       protected
         def parent_segment=(s)
           @parent_segment = s
@@ -251,57 +251,57 @@ module NewRelic
     end
 
     class SummarySegment < Segment
-      
-      
+
+
       def initialize(segment)
         super segment.entry_timestamp, segment.metric_name, nil
-        
+
         add_segments segment.called_segments
-        
+
         end_trace segment.exit_timestamp
       end
-      
+
       def add_segments(segments)
         segments.collect do |segment|
           SummarySegment.new(segment)
         end.each {|segment| add_called_segment(segment)}
       end
-      
+
     end
-    
+
     class CompositeSegment < Segment
       attr_reader :detail_segments
-      
+
       def initialize(segments)
         summary = SummarySegment.new(segments.first)
         super summary.entry_timestamp, "Repeating pattern (#{segments.length} repeats)", nil
-        
+
         summary.end_trace(segments.last.exit_timestamp)
-        
+
         @detail_segments = segments.clone
-        
+
         add_called_segment(summary)
         end_trace summary.exit_timestamp
       end
-      
+
       def detail_segments=(segments)
         @detail_segments = segments
       end
-      
+
     end
-    
+
     class << self
       def obfuscate_sql(sql)
-        NewRelic::Agent.instance.obfuscator.call(sql) 
+        NewRelic::Agent.instance.obfuscator.call(sql)
       end
-      
+
       def get_connection(config)
         @@connections ||= {}
-        
+
         connection = @@connections[config]
-        
+
         return connection if connection
-        
+
         begin
           connection = ActiveRecord::Base.send("#{config[:adapter]}_connection", config)
           @@connections[config] = connection
@@ -311,7 +311,7 @@ module NewRelic
           nil
         end
       end
-      
+
       def close_connections
         @@connections ||= {}
         @@connections.values.each do |connection|
@@ -320,17 +320,17 @@ module NewRelic
           rescue
           end
         end
-        
+
         @@connections = {}
       end
-      
+
     end
 
     attr_accessor :profile
     attr_reader :root_segment
     attr_reader :params
     attr_reader :sample_id
-    
+
     def initialize(time = Time.now.to_f, sample_id = nil)
       @sample_id = sample_id || object_id
       @start_time = time
@@ -342,71 +342,71 @@ module NewRelic
     def count_segments
       @root_segment.count_segments - 1    # don't count the root segment
     end
-    
+
     def truncate(max)
       original_count = count_segments
-      
+
       return if original_count <= max
-      
+
       @root_segment.truncate(max-1)
-      
+
       if params[:segment_count].nil?
         params[:segment_count] = original_count
       end
     end
-    
+
     # offset from start of app
     def timestamp
       @start_time - @@start_time.to_f
     end
-    
+
     # Used in the server only
     def to_json(options = {}) #:nodoc:
       map = {:sample_id => @sample_id,
         :start_time => @start_time,
         :root_segment => @root_segment}
       if @params && !@params.empty?
-        map[:params] = @params  
+        map[:params] = @params
       end
       map.to_json
     end
-    
-   
+
+
 
     def start_time
       Time.at(@start_time)
     end
-    
+
     def path_string
       @root_segment.path_string
     end
-    
+
     def create_segment(relative_timestamp, metric_name, segment_id = nil)
       raise TypeError.new("Frozen Transaction Sample") if frozen?
-      NewRelic::TransactionSample::Segment.new(relative_timestamp, metric_name, segment_id)    
+      NewRelic::TransactionSample::Segment.new(relative_timestamp, metric_name, segment_id)
     end
-    
+
     def duration
       root_segment.duration
     end
-    
+
     def each_segment(&block)
       @root_segment.each_segment(&block)
     end
-    
+
     def to_s_compact
       @root_segment.to_s_compact
     end
-    
+
     def find_segment(id)
       @root_segment.find_segment(id)
     end
-    
+
     def to_s
       s = "Transaction Sample collected at #{start_time}\n"
       s << "  {\n"
       s << "  Path: #{params[:path]} \n"
-      
+
       params.each do |k,v|
         next if k == :path
         s << "  #{k}: " <<
@@ -422,7 +422,7 @@ module NewRelic
       s << "  }\n\n"
       s <<  @root_segment.to_debug_str(0)
     end
-    
+
     # return a new transaction sample that treats segments
     # with the given regular expression in their name as if they
     # were never called at all.  This allows us to strip out segments
@@ -430,39 +430,39 @@ module NewRelic
     # normally show up in production (like Rails/Application Code Loading)
     def omit_segments_with(regex)
       regex = Regexp.new(regex)
-      
+
       sample = TransactionSample.new(@start_time, sample_id)
-      
+
       params.each {|k,v| sample.params[k] = v}
-        
+
       delta = build_segment_with_omissions(sample, 0.0, @root_segment, sample.root_segment, regex)
       sample.root_segment.end_trace(@root_segment.exit_timestamp - delta)
       sample.profile = self.profile
       sample
     end
-    
+
     # return a new transaction sample that can be sent to the RPM service.
     # this involves potentially one or more of the following options
-    # 
+    #
     #   :explain_sql : run EXPLAIN on all queries whose response times equal the value for this key
     #       (for example :explain_sql => 2.0 would explain everything over 2 seconds.  0.0 would explain everything.)
     #   :keep_backtraces : keep backtraces, significantly increasing size of trace (off by default)
     #   :record_sql => [ :raw | :obfuscated] : copy over the sql, obfuscating if necessary
     def prepare_to_send(options={})
       sample = TransactionSample.new(@start_time, sample_id)
-      
+
       sample.params.merge! self.params
-      
+
       begin
         build_segment_for_transfer(sample, @root_segment, sample.root_segment, options)
       ensure
         self.class.close_connections
       end
-      
-      sample.root_segment.end_trace(@root_segment.exit_timestamp) 
+
+      sample.root_segment.end_trace(@root_segment.exit_timestamp)
       sample
     end
-    
+
     def analyze
       sample = self
       original_path_string = nil
@@ -474,27 +474,27 @@ module NewRelic
         sample = new_sample
         return sample if sample.path_string.to_s == original_path_string
       end
-      
+
     end
-    
+
     def params=(params)
       @params = params
     end
 
   private
-  
+
     def analyze_called_segments(called_segments)
       path = nil
       like_segments = []
-      
-      segments = [] 
-      
+
+      segments = []
+
       called_segments.each do |segment|
         segment = segment.dup
         segment.called_segments = analyze_called_segments(segment.called_segments)
-        
+
         current_path = segment.path_string
-        if path == current_path 
+        if path == current_path
           like_segments << segment
         else
           segments += summarize_segments(like_segments)
@@ -505,10 +505,10 @@ module NewRelic
         end
       end
       segments += summarize_segments(like_segments)
-      
+
       segments
     end
-    
+
     def summarize_segments(like_segments)
       if like_segments.length > COLLAPSE_SEGMENTS_THRESHOLD
         [CompositeSegment.new(like_segments)]
@@ -516,33 +516,33 @@ module NewRelic
         like_segments
       end
     end
-    
+
     def build_segment_with_omissions(new_sample, time_delta, source_segment, target_segment, regex)
       source_segment.called_segments.each do |source_called_segment|
         # if this segment's metric name matches the given regular expression, bail
         # here and increase the amount of time that we reduce the target sample with
         # by this omitted segment's duration.
         do_omit = regex =~ source_called_segment.metric_name
-        
+
         if do_omit
           time_delta += source_called_segment.duration
         else
           target_called_segment = new_sample.create_segment(
-                source_called_segment.entry_timestamp - time_delta, 
+                source_called_segment.entry_timestamp - time_delta,
                 source_called_segment.metric_name,
                 source_called_segment.segment_id)
-          
+
           target_segment.add_called_segment target_called_segment
           source_called_segment.params.each do |k,v|
             target_called_segment[k]=v
           end
-          
+
           time_delta = build_segment_with_omissions(
                 new_sample, time_delta, source_called_segment, target_called_segment, regex)
           target_called_segment.end_trace(source_called_segment.exit_timestamp - time_delta)
         end
       end
-      
+
       return time_delta
     end
 
@@ -564,7 +564,7 @@ module NewRelic
             if options[:record_sql] && options[:record_sql] && options[:explain_sql] && source_called_segment.duration > options[:explain_sql].to_f
               target_called_segment[:explanation] = source_called_segment.explain_sql
             end
-            
+
             target_called_segment[:sql] = case options[:record_sql]
               when :raw then v
               when :obfuscated then TransactionSample.obfuscate_sql(v)
@@ -573,7 +573,7 @@ module NewRelic
           when :connection_config
             # don't copy it
           else
-            target_called_segment[k]=v 
+            target_called_segment[k]=v
           end
         end
 
@@ -581,6 +581,6 @@ module NewRelic
         target_called_segment.end_trace(source_called_segment.exit_timestamp)
       end
     end
-    
+
   end
 end