ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/lib/new_relic/metric_data.rb

@@ -1,7 +1,10 @@
 module NewRelic
   class MetricData
+    # nil, or a NewRelic::MetricSpec object if we have no cached ID
     attr_accessor :metric_spec
+    # nil or a cached integer ID for the metric from the collector.
     attr_accessor :metric_id
+    # the actual statistics object
     attr_accessor :stats
 
     def initialize(metric_spec, stats, metric_id)
@@ -17,7 +20,9 @@ module NewRelic
     def original_spec
       @original_spec || @metric_spec
     end
-
+    
+    # assigns a new metric spec, and retains the old metric spec as
+    # @original_spec if it exists currently
     def metric_spec= new_spec
       @original_spec = @metric_spec if @metric_spec
       @metric_spec = new_spec
@@ -31,7 +36,7 @@ module NewRelic
     def to_json(*a)
        %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
     end
-
+    
     def to_s
       if metric_spec
         "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"

data/lib/new_relic/metric_spec.rb

@@ -3,21 +3,24 @@
 class NewRelic::MetricSpec
   attr_accessor   :name
   attr_accessor   :scope
-
+  
+  # the maximum length of a metric name or metric scope
   MAX_LENGTH = 255
+  LENGTH_RANGE = (0...MAX_LENGTH)
   # Need a "zero-arg" constructor so it can be instantiated from java (using
   # jruby) for sending responses to ruby agents from the java collector.
   #
   def initialize(metric_name = '', metric_scope = '')
-    self.name = (metric_name || '') && metric_name[0...MAX_LENGTH]
-    self.scope = metric_scope && metric_scope[0...MAX_LENGTH]
+    self.name = (metric_name || '') && metric_name[LENGTH_RANGE]
+    self.scope = metric_scope && metric_scope[LENGTH_RANGE]
   end
-
+  
+  # truncates the name and scope to the MAX_LENGTH
   def truncate!
-    self.name = name[0...MAX_LENGTH] if name && name.size > MAX_LENGTH
-    self.scope = scope[0...MAX_LENGTH] if scope && scope.size > MAX_LENGTH
+    self.name = name[LENGTH_RANGE] if name && name.size > MAX_LENGTH
+    self.scope = scope[LENGTH_RANGE] if scope && scope.size > MAX_LENGTH
   end
-
+  
   def ==(o)
     self.eql?(o)
   end
@@ -40,10 +43,10 @@ class NewRelic::MetricSpec
     NewRelic::Control.instance.log.warn("The sub method on metric specs is deprecated") rescue nil
     return nil if name !~ pattern &&
      (!apply_to_scope || scope.nil? || scope !~ pattern)
-    new_name = name.sub(pattern, replacement)[0...MAX_LENGTH]
+    new_name = name.sub(pattern, replacement)[LENGTH_RANGE]
 
     if apply_to_scope
-      new_scope = (scope && scope.sub(pattern, replacement)[0...MAX_LENGTH])
+      new_scope = (scope && scope.sub(pattern, replacement)[LENGTH_RANGE])
     else
       new_scope = scope
     end

data/lib/new_relic/noticed_error.rb

@@ -18,7 +18,12 @@ class NewRelic::NoticedError
     # clamp long messages to 4k so that we don't send a lot of
     # overhead across the wire
     self.message = self.message[0..4095] if self.message.length > 4096
-
+    
+    # obfuscate error message if necessary
+    if NewRelic::Control.instance.fetch('high_security', false)
+      self.message = NewRelic::Agent::Database.obfuscate_sql(self.message)
+    end
+    
     self.timestamp = timestamp
   end
 end

data/lib/new_relic/rack/browser_monitoring.rb

@@ -9,19 +9,14 @@ module NewRelic::Rack
 
     # method required by Rack interface
     def call(env)
-      
-      # clear out the thread locals we use in case this is a static request
-      Thread.current[:newrelic_most_recent_transaction] = nil
-      Thread.current[:newrelic_start_time] = Time.now
-      Thread.current[:newrelic_queue_time] = 0
-      
       result = @app.call(env)   # [status, headers, response]
 
       if (NewRelic::Agent.browser_timing_header != "") && should_instrument?(result[0], result[1])
         response_string = autoinstrument_source(result[2], result[1])
 
-        if (response_string)
-          Rack::Response.new(response_string, result[0], result[1]).finish
+        if response_string
+          response = Rack::Response.new(response_string, result[0], result[1])
+          response.finish
         else
           result
         end
@@ -31,27 +26,30 @@ module NewRelic::Rack
     end
 
     def should_instrument?(status, headers)
-      status == 200 && headers["Content-Type"] && headers["Content-Type"].include?("text/html")
+      status == 200 && headers["Content-Type"] && headers["Content-Type"].include?("text/html") &&
+        !headers['Content-Disposition'].to_s.include?('attachment')
     end
 
     def autoinstrument_source(response, headers)
       source = nil
-      response.each {|fragment| (source) ? (source << fragment) : (source = fragment)}
+      response.each {|fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
       return nil unless source
-      
-      body_start = source.index("<body")
-      body_close = source.rindex("</body>")
 
-      if body_start && body_close
+
+      # Only scan the first 50k (roughly) then give up.
+      beginning_of_source = source[0..50_000]
+      # Don't scan for body close unless we find body start
+      if (body_start = beginning_of_source.index("<body")) && (body_close = source.rindex("</body>"))
+
         footer = NewRelic::Agent.browser_timing_footer
         header = NewRelic::Agent.browser_timing_header
-                  
-        if source.include?('X-UA-Compatible')
+
+        if beginning_of_source.include?('X-UA-Compatible')
           # put at end of header if UA-Compatible meta tag found
-          head_pos = source.index("</head>")          
-        elsif head_open = source.index("<head")
+          head_pos = beginning_of_source.index("</head>")
+        elsif head_open = beginning_of_source.index("<head")
           # put at the beginning of the header
-          head_pos = source.index(">", head_open) + 1
+          head_pos = beginning_of_source.index(">", head_open) + 1
         else
           # put the header right above body start
           head_pos = body_start
@@ -65,4 +63,5 @@ module NewRelic::Rack
       source
     end
   end
+
 end

data/lib/new_relic/rack/developer_mode.rb

@@ -67,6 +67,7 @@ module NewRelic
 
       def reset
         NewRelic::Agent.instance.transaction_sampler.reset!
+        NewRelic::Agent.instance.sql_sampler.reset!
         ::Rack::Response.new{|r| r.redirect('/newrelic/')}.finish
       end
 
@@ -82,9 +83,9 @@ module NewRelic
           @obfuscated_sql = @segment.obfuscated_sql
         end
 
-        explanations = @segment.explain_sql
+        headers, explanations = @segment.explain_sql
         if explanations
-          @explanation = explanations.first
+          @explanation = explanations
           if !@explanation.blank?
             first_row = @explanation.first
             # Show the standard headers if it looks like a mysql explain plan

data/lib/new_relic/recipes.rb

@@ -33,10 +33,14 @@ make_notify_task = Proc.new do
           end
           changelog = `#{log_command}`
         end
-        new_revision = rev || source.query_revision(source.head()) do |cmd|
-          logger.debug "executing locally: '#{cmd}'"
-          `#{cmd}`
+        if rev.nil?
+          rev = source.query_revision(source.head()) do |cmd|
+            logger.debug "executing locally: '#{cmd}'"
+            `#{cmd}`
+          end
+          rev = rev[0..6] if scm == :git
         end
+        new_revision = rev
         deploy_options = { :environment => rails_env,
           :revision => new_revision,
           :changelog => changelog,
@@ -50,7 +54,7 @@ make_notify_task = Proc.new do
         logger.info e.message
       rescue Capistrano::CommandError
         logger.info "Unable to notify New Relic of the deployment... skipping"
-      rescue Exception => e
+      rescue => e
         logger.info "Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}"
       end
       # WIP: For rollbacks, let's update the deployment we created with an indication of the failure:

data/lib/new_relic/stats.rb

@@ -1,12 +1,13 @@
 
 module NewRelic
   module Stats
-
+    
+    # a stat is absent if its call count equals zero
     def absent?
-      # guess on absent values
       call_count == 0
     end
-
+    
+    # outputs a useful human-readable time given a value in milliseconds
     def time_str(value_ms)
       case
       when value_ms >= 10000
@@ -26,7 +27,7 @@ module NewRelic
         numerator.to_f / denominator
       end
     end
-
+    
     def average_call_time
       checked_calculation(total_call_time, call_count)
     end
@@ -46,6 +47,7 @@ module NewRelic
     def sum_attributes(other)
       update_totals(other)
       stack_min_max_from(other)
+      self.call_count = [self.call_count, other.call_count].max
       update_boundaries(other)
     end
 
@@ -102,43 +104,6 @@ module NewRelic
       stats.merge!(other_stats)
     end
 
-    # split into an array of timeslices whose
-    # time boundaries start on (begin_time + (n * duration)) and whose
-    # end time ends on (begin_time * (n + 1) * duration), except for the
-    # first and last elements, whose begin time and end time are the begin
-    # and end times of this stats instance, respectively.  Yield to caller
-    # for the code that creates the actual stats instance
-    def split(rollup_begin_time, rollup_period)
-      rollup_begin_time = rollup_begin_time.to_f
-      rollup_begin_time += ((self.begin_time - rollup_begin_time) / rollup_period).floor * rollup_period
-
-      current_begin_time = self.begin_time
-      current_end_time = rollup_begin_time + rollup_period
-
-      return [self] if current_end_time >= self.end_time
-
-      timeslices = []
-      while current_end_time < self.end_time do
-        ts = yield(current_begin_time, current_end_time)
-        if ts
-          ts.fraction_of(self)
-          timeslices << ts
-        end
-        current_begin_time = current_end_time
-        current_end_time = current_begin_time + rollup_period
-      end
-
-      if self.end_time > current_begin_time
-        percentage = rollup_period / self.duration + (self.begin_time - rollup_begin_time) / rollup_period
-        ts = yield(current_begin_time, self.end_time)
-        if ts
-          ts.fraction_of(self)
-          timeslices << ts
-        end
-      end
-
-      timeslices
-    end
 
     def is_reset?
       call_count == 0 && total_call_time == 0.0 && total_exclusive_time == 0.0
@@ -214,22 +179,6 @@ module NewRelic
       "[#{Time.at(begin_time.to_f).utc.strftime(format)} UTC, #{'%2.3fs' % duration.to_f}; #{'%2i' % call_count.to_i} calls #{'%4i' % average_call_time.to_f}s]"
     end
 
-    # calculate this set of stats to be a percentage fraction
-    # of the provided stats, which has an overlapping time window.
-    # used as a key part of the split algorithm
-    def fraction_of(s)
-      min_end = (end_time < s.end_time ? end_time : s.end_time)
-      max_begin = (begin_time > s.begin_time ? begin_time : s.begin_time)
-      percentage = (min_end - max_begin) / s.duration
-
-      self.total_exclusive_time = s.total_exclusive_time * percentage
-      self.total_call_time = s.total_call_time * percentage
-      self.min_call_time = s.min_call_time
-      self.max_call_time = s.max_call_time
-      self.call_count = s.call_count * percentage
-      self.sum_of_squares = (s.sum_of_squares || 0) * percentage
-    end
-
     # multiply the total time and rate by the given percentage
     def multiply_by(percentage)
       self.total_call_time = total_call_time * percentage
@@ -336,7 +285,10 @@ module NewRelic
     end
 
     alias trace_call record_data_point
-
+    
+    # Records multiple data points as one method call - this handles
+    # all the aggregation that would be done with multiple
+    # record_data_point calls
     def record_multiple_data_points(total_value, count=1)
       return record_data_point(total_value) if count == 1
       @call_count += count
@@ -348,11 +300,13 @@ module NewRelic
       @sum_of_squares += (avg_val * avg_val) * count
       self
     end
-
+    
+    # increments the call_count by one
     def increment_count(value = 1)
       @call_count += value
     end
-
+    
+    # outputs a human-readable version of the MethodTraceStats object
     def inspect
       "#<NewRelic::MethodTraceStats #{summary} >"
     end
@@ -369,6 +323,9 @@ module NewRelic
       unscoped_stats.trace_call call_time, exclusive_time
       super call_time, exclusive_time
     end
+    # Records multiple data points as one method call - this handles
+    # all the aggregation that would be done with multiple
+    # trace_call calls    
     def record_multiple_data_points(total_value, count=1)
       unscoped_stats.record_multiple_data_points(total_value, count)
       super total_value, count

data/lib/new_relic/transaction_analysis.rb

@@ -15,11 +15,12 @@ module NewRelic
     # limit the data set to the top n
     def breakdown_data(limit = nil)
       metric_hash = {}
-      each_segment do |segment|
+      each_segment_with_nest_tracking do |segment|
         unless segment == root_segment
           metric_name = segment.metric_name
           metric_hash[metric_name] ||= SegmentSummary.new(metric_name, self)
           metric_hash[metric_name] << segment
+          metric_hash[metric_name]
         end
       end
 

data/lib/new_relic/transaction_analysis/segment_summary.rb

@@ -3,11 +3,12 @@ module NewRelic
     # summarizes performance data for all calls to segments
     # with the same metric_name
     class SegmentSummary
-      attr_accessor :metric_name, :total_time, :exclusive_time, :call_count
+      attr_accessor :metric_name, :total_time, :exclusive_time, :call_count, :current_nest_count
       def initialize(metric_name, sample)
         @metric_name = metric_name
         @total_time, @exclusive_time, @call_count = 0,0,0
         @sample = sample
+        @current_nest_count = 0
       end
 
       def <<(segment)
@@ -15,7 +16,8 @@ module NewRelic
           raise ArgumentError, "Metric Name Mismatch: #{segment.metric_name} != #{metric_name}"
         end
 
-        @total_time += segment.duration
+        # a nested segment should use the sum of the top level totals
+        @total_time += segment.duration if current_nest_count == 0
         @exclusive_time += segment.exclusive_duration
         @call_count += 1
       end

data/lib/new_relic/transaction_sample.rb

@@ -3,89 +3,45 @@ require 'new_relic/transaction_sample/summary_segment'
 require 'new_relic/transaction_sample/fake_segment'
 require 'new_relic/transaction_sample/composite_segment'
 module NewRelic
+  # the number of segments that need to exist before we roll them up
+  # into one segment with multiple executions
   COLLAPSE_SEGMENTS_THRESHOLD = 2
 
-  MYSQL_EXPLAIN_COLUMNS = [
-        "Id",
-        "Select Type",
-        "Table",
-        "Type",
-        "Possible Keys",
-        "Key",
-        "Key Length",
-        "Ref",
-        "Rows",
-        "Extra"
-      ].freeze
-
   class TransactionSample
 
-    attr_accessor :params, :root_segment
-    attr_accessor :profile
-    attr_reader :root_segment
-    attr_reader :params
-    attr_reader :sample_id
+    attr_accessor :params, :root_segment, :profile, :force_persist, :guid
+    attr_reader :root_segment, :params, :sample_id
 
     @@start_time = Time.now
 
     include TransactionAnalysis
 
-    class << self
-      def obfuscate_sql(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
-        rescue => e
-          NewRelic::Agent.agent.log.error("Caught exception #{e} trying to get connection to DB for explain. Control: #{config}")
-          NewRelic::Agent.agent.log.error(e.backtrace.join("\n"))
-          nil
-        end
-      end
-
-      def close_connections
-        @@connections ||= {}
-        @@connections.values.each do |connection|
-          begin
-            connection.disconnect!
-          rescue
-          end
-        end
-
-        @@connections = {}
-      end
-
-    end
-
     def initialize(time = Time.now.to_f, sample_id = nil)
       @sample_id = sample_id || object_id
       @start_time = time
+      @params = { :segment_count => -1, :request_params => {} }
+      @segment_count = -1
       @root_segment = create_segment 0.0, "ROOT"
-      @params = {}
-      @params[:request_params] = {}
+
+      @guid = generate_guid
+      NewRelic::Agent::TransactionInfo.get.guid = @guid
     end
 
     def count_segments
-      @root_segment.count_segments - 1    # don't count the root segment
+      @segment_count
     end
 
+    # Truncates the transaction sample to a maximum length determined
+    # by the passed-in parameter. Operates recursively on the entire
+    # tree of transaction segments in a depth-first manner
     def truncate(max)
-      count = count_segments
-      return if count < max
+      return if @segment_count < max
       @root_segment.truncate(max + 1)
-
-      ensure_segment_count_set(count)
+      @segment_count = max
     end
 
+    # makes sure that the parameter cache for segment count is set to
+    # the correct value
     def ensure_segment_count_set(count)
       params[:segment_count] ||= count
     end
@@ -116,6 +72,8 @@ module NewRelic
 
     def create_segment(relative_timestamp, metric_name, segment_id = nil)
       raise TypeError.new("Frozen Transaction Sample") if frozen?
+      @params[:segment_count] += 1
+      @segment_count += 1
       NewRelic::TransactionSample::Segment.new(relative_timestamp, metric_name, segment_id)
     end
 
@@ -123,14 +81,24 @@ module NewRelic
       root_segment.duration
     end
 
+    # Iterates recursively over each segment in the entire transaction
+    # sample tree
     def each_segment(&block)
       @root_segment.each_segment(&block)
     end
 
+    # Iterates recursively over each segment in the entire transaction
+    # sample tree while keeping track of nested segments
+    def each_segment_with_nest_tracking(&block)
+      @root_segment.each_segment_with_nest_tracking(&block)
+    end
+
     def to_s_compact
       @root_segment.to_s_compact
     end
 
+    # Searches the tree recursively for the segment with the given
+    # id. note that this is an internal id, not an ActiveRecord id
     def find_segment(id)
       @root_segment.find_segment(id)
     end
@@ -147,6 +115,7 @@ module NewRelic
           when Enumerable then v.map(&:to_s).sort.join("; ")
           when String then v
           when Float then '%6.3s' % v
+          when Fixnum then v.to_s
           when nil then ''
         else
           raise "unexpected value type for #{k}: '#{v}' (#{v.class})"
@@ -165,9 +134,10 @@ module NewRelic
       regex = Regexp.new(regex)
 
       sample = TransactionSample.new(@start_time, sample_id)
-
-      params.each {|k,v| sample.params[k] = v}
-
+      
+      sample.params = params.dup
+      sample.params[:segment_count] = 0
+      
       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
@@ -186,13 +156,11 @@ module NewRelic
       sample = TransactionSample.new(@start_time, sample_id)
 
       sample.params.merge! self.params
+      sample.guid = self.guid
+      sample.force_persist = self.force_persist if self.force_persist
 
-      begin
-        build_segment_for_transfer(sample, @root_segment, sample.root_segment, options)
-      ensure
-        self.class.close_connections
-      end
-
+      build_segment_for_transfer(sample, @root_segment, sample.root_segment, options)
+      
       sample.root_segment.end_trace(@root_segment.exit_timestamp)
       sample
     end
@@ -203,6 +171,19 @@ module NewRelic
 
   private
 
+
+
+    HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
+    # generate a random 64 bit uuid
+    def generate_guid
+      guid = ''
+      HEX_DIGITS.each do |a|
+        guid << HEX_DIGITS[rand(16)]
+      end
+      guid
+    end
+
+    # This is badly in need of refactoring
     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
@@ -233,6 +214,8 @@ module NewRelic
     end
 
     # see prepare_to_send for what we do with options
+    #
+    # This is badly in need of refactoring
     def build_segment_for_transfer(new_sample, source_segment, target_segment, options)
       source_segment.called_segments.each do |source_called_segment|
         target_called_segment = new_sample.create_segment(
@@ -242,20 +225,22 @@ module NewRelic
 
         target_segment.add_called_segment target_called_segment
         source_called_segment.params.each do |k,v|
-        case k
+          case k
           when :backtrace
             target_called_segment[k]=v if options[:keep_backtraces]
           when :sql
             # run an EXPLAIN on this sql if specified.
-            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
+            if options[:record_sql] && options[:record_sql] &&
+                options[:explain_sql] &&
+                source_called_segment.duration > options[:explain_sql].to_f
+              target_called_segment[:explain_plan] = 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)
+              when :obfuscated then NewRelic::Agent::Database.obfuscate_sql(v)
               else raise "Invalid value for record_sql: #{options[:record_sql]}"
-            end if options[:record_sql]
+            end.to_s if options[:record_sql]
           when :connection_config
             # don't copy it
           else