newrelic_rpm 3.11.2.286 → 3.12.0.288

data/lib/new_relic/agent/transaction/force_persist_sample_buffer.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/agent/transaction/transaction_sample_buffer'
-
-module NewRelic
-  module Agent
-    class Transaction
-      class ForcePersistSampleBuffer < TransactionSampleBuffer
-
-        CAPACITY = 10
-
-        def capacity
-          CAPACITY
-        end
-
-        def allow_sample?(sample)
-          sample.force_persist
-        end
-
-      end
-    end
-  end
-end

data/lib/new_relic/transaction_analysis.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/transaction_analysis/segment_summary'
-# Add these methods to TransactionSample that enable performance analysis in the user interface.
-module NewRelic
-  module TransactionAnalysis
-    def database_time
-      time_percentage(/^Database\/.*/)
-    end
-
-    def render_time
-      time_percentage(/^View\/.*/)
-    end
-
-    # return the data that breaks down the performance of the transaction
-    # as an array of SegmentSummary objects.  If a limit is specified, then
-    # limit the data set to the top n
-    def breakdown_data(limit = nil)
-      metric_hash = {}
-      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 = metric_hash.values
-
-      data.sort! do |x,y|
-        y.exclusive_time <=> x.exclusive_time
-      end
-
-      if limit && data.length > limit
-        data = data[0..limit - 1]
-      end
-
-      # add one last segment for the remaining time if any
-      remainder = duration
-      data.each do |segment|
-        remainder -= segment.exclusive_time
-      end
-
-      if (remainder*1000).round > 0
-        remainder_summary = SegmentSummary.new('Remainder', self)
-        remainder_summary.total_time = remainder_summary.exclusive_time = remainder
-        remainder_summary.call_count = 1
-        data << remainder_summary
-      end
-
-      data
-    end
-
-    # return an array of sql statements executed by this transaction
-    # each element in the array contains [sql, parent_segment_metric_name, duration]
-    def sql_segments(show_non_sql_segments = true)
-      segments = []
-      each_segment do |segment|
-        segments << segment if segment[:sql] || segment[:sql_obfuscated] || (show_non_sql_segments && segment[:key])
-      end
-      segments
-    end
-
-    private
-    def time_percentage(regex)
-      total = 0
-      each_segment do |segment|
-        if regex =~ segment.metric_name
-          total += segment.duration
-        end
-      end
-      fraction = 100.0 * total / duration
-      # percent value rounded to two digits:
-      return (100 * fraction).round / 100.0
-    end
-  end
-end

data/lib/new_relic/transaction_analysis/segment_summary.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module NewRelic
-  module TransactionAnalysis
-    # 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, :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)
-        if metric_name != segment.metric_name
-          raise ArgumentError, "Metric Name Mismatch: #{segment.metric_name} != #{metric_name}"
-        end
-
-        # 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
-
-      def average_time
-        @total_time / @call_count
-      end
-
-      def average_exclusive_time
-        @exclusive_time / @call_count
-      end
-
-      def exclusive_time_percentage
-        return 0 unless @exclusive_time && @sample.duration && @sample.duration > 0
-        @exclusive_time / @sample.duration
-      end
-
-      def total_time_percentage
-        return 0 unless @total_time && @sample.duration && @sample.duration > 0
-        @total_time / @sample.duration
-      end
-
-      def ui_name
-        return @metric_name if @metric_name == 'Remainder'
-        NewRelic::MetricParser::MetricParser.parse(@metric_name).developer_name
-      end
-    end
-  end
-end

data/lib/new_relic/transaction_sample.rb

@@ -1,207 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'base64'
-
-require 'new_relic/transaction_sample/segment'
-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
-
-  class TransactionSample
-
-    attr_accessor :params, :root_segment, :profile, :force_persist, :guid,
-                  :threshold, :finished, :xray_session_id, :start_time,
-                  :synthetics_resource_id
-    attr_reader :root_segment, :params, :sample_id
-    attr_writer :prepared
-
-    @@start_time = Time.now
-
-    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"
-      @prepared = false
-    end
-
-    def prepared?
-      @prepared
-    end
-
-    def count_segments
-      @segment_count
-    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
-
-    # offset from start of app
-    def timestamp
-      @start_time - @@start_time.to_f
-    end
-
-    def set_custom_param(name, value)
-      @params[:custom_params] ||= {}
-      @params[:custom_params][name] = value
-    end
-
-    include NewRelic::Coerce
-
-    def to_array
-      [ float(@start_time),
-        @params[:request_params],
-        @params[:custom_params],
-        @root_segment.to_array ]
-    end
-
-    def to_collector_array(encoder)
-      trace_tree = encoder.encode(self.to_array)
-      [ Helper.time_to_millis(@start_time),
-        Helper.time_to_millis(duration),
-        string(transaction_name),
-        string(@params[:uri]),
-        trace_tree,
-        string(@guid),
-        nil,
-        forced?,
-        int_or_nil(xray_session_id),
-        string(synthetics_resource_id)
-      ]
-    end
-
-    def path_string
-      @root_segment.path_string
-    end
-
-    def transaction_name
-      @params[:path]
-    end
-
-    def transaction_name=(new_name)
-      @params[:path] = new_name
-    end
-
-    def forced?
-      !!@force_persist || !int_or_nil(xray_session_id).nil?
-    end
-
-    # relative_timestamp is seconds since the start of the transaction
-    def create_segment(relative_timestamp, metric_name=nil)
-      raise TypeError.new("Frozen Transaction Sample") if finished
-      @params[:segment_count] += 1
-      @segment_count += 1
-      NewRelic::TransactionSample::Segment.new(relative_timestamp, metric_name)
-    end
-
-    def duration
-      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
-
-    def to_s
-      s = "Transaction Sample collected at #{Time.at(start_time)}\n"
-      s << "  {\n"
-      s << "  Path: #{params[:path]} \n"
-
-      params.each do |k,v|
-        next if k == :path
-        s << "  #{k}: " <<
-        case v
-          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})"
-        end << "\n"
-      end
-      s << "  }\n\n"
-      s <<  @root_segment.to_debug_str(0)
-    end
-
-    # Return a new transaction sample that can be sent to the New
-    # Relic service.
-    def prepare_to_send!
-      return self if @prepared
-
-      if Agent::Database.should_record_sql?
-        collect_explain_plans!
-        prepare_sql_for_transmission!
-      else
-        strip_sql!
-      end
-
-      @prepared = true
-      self
-    end
-
-    def params=(params)
-      @params = params
-    end
-
-  private
-
-    def strip_sql!
-      each_segment do |segment|
-        segment.params.delete(:sql)
-      end
-    end
-
-    def collect_explain_plans!
-      return unless Agent::Database.should_collect_explain_plans?
-      threshold = Agent.config[:'transaction_tracer.explain_threshold']
-      each_segment do |segment|
-        if segment[:sql] && segment.duration > threshold
-          segment[:explain_plan] = segment.explain_sql
-        end
-      end
-    end
-
-    def prepare_sql_for_transmission!
-      strategy = Agent::Database.record_sql_method
-      each_segment do |segment|
-        if segment[:sql]
-          segment[:sql] = case strategy
-          when :raw
-            segment[:sql].to_s
-          when :obfuscated
-            Agent::Database.obfuscate_sql(segment[:sql]).to_s
-          end
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/transaction_sample/composite_segment.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/transaction_sample'
-require 'new_relic/transaction_sample/segment'
-require 'new_relic/transaction_sample/summary_segment'
-module NewRelic
-  class TransactionSample
-    class CompositeSegment < Segment
-      attr_reader :detail_segments
-
-      def initialize(segments)
-        summary = SummarySegment.new(segments.first)
-        super summary.entry_timestamp, "Repeating pattern (#{segments.length} repeats)"
-
-        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
-  end
-end

data/lib/new_relic/transaction_sample/fake_segment.rb

@@ -1,13 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/transaction_sample'
-require 'new_relic/transaction_sample/segment'
-module NewRelic
-  class TransactionSample
-    class FakeSegment < Segment
-      public :parent_segment=
-    end
-  end
-end

data/lib/new_relic/transaction_sample/segment.rb

@@ -1,197 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/transaction_sample'
-
-module NewRelic
-  class TransactionSample
-    class Segment
-      attr_reader :entry_timestamp
-      # The exit timestamp will be relative except for the outermost sample which will
-      # have a timestamp.
-      attr_reader :exit_timestamp
-      attr_reader :parent_segment
-
-      # This is only used from developer mode and rpm_site.
-      # No new clients should be added.
-      attr_reader :segment_id
-
-      attr_accessor :metric_name
-
-      UNKNOWN_SEGMENT_NAME = '<unknown>'.freeze
-
-      def initialize(timestamp, metric_name, segment_id=nil)
-        @entry_timestamp = timestamp
-        @metric_name     = metric_name || UNKNOWN_SEGMENT_NAME
-        @segment_id      = segment_id  || object_id
-      end
-
-      # sets the final timestamp on a segment to indicate the exit
-      # point of the segment
-      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
-
-      include NewRelic::Coerce
-
-      def to_array
-        [ NewRelic::Helper.time_to_millis(@entry_timestamp),
-          NewRelic::Helper.time_to_millis(@exit_timestamp),
-          string(@metric_name),
-          (@params || {}) ] +
-          [ (@called_segments ? @called_segments.map{|s| s.to_array} : []) ]
-      end
-
-      def path_string
-        "#{metric_name}[#{called_segments.collect {|segment| segment.path_string }.join('')}]"
-      end
-
-      def to_s_compact
-        str = ""
-        str << metric_name
-        if called_segments.any?
-          str << "{#{called_segments.map { | cs | cs.to_s_compact }.join(",")}}"
-        end
-        str
-      end
-
-      def to_debug_str(depth)
-        tab = "  " * depth
-        s = tab.clone
-        s << ">> #{'%3i ms' % (@entry_timestamp*1000)} [#{self.class.name.split("::").last}] #{metric_name} \n"
-        unless params.empty?
-          params.each do |k,v|
-            s << "#{tab}    -#{'%-16s' % k}: #{v.to_s[0..80]}\n"
-          end
-        end
-        called_segments.each do |cs|
-          s << cs.to_debug_str(depth + 1)
-        end
-        s << tab + "<< "
-        s << case @exit_timestamp
-             when nil then ' n/a'
-             when Numeric then '%3i ms' % (@exit_timestamp*1000)
-             else @exit_timestamp.to_s
-             end
-        s << " #{metric_name}\n"
-      end
-
-      def called_segments
-        @called_segments || []
-      end
-
-      # return the total duration of this segment
-      def duration
-        (@exit_timestamp - @entry_timestamp).to_f
-      end
-
-      # return the duration of this segment without
-      # including the time in the called segments
-      def exclusive_duration
-        d = duration
-
-        called_segments.each do |segment|
-          d -= segment.duration
-        end
-        d
-      end
-
-      def count_segments
-        count = 1
-        called_segments.each { | seg | count  += seg.count_segments }
-        count
-      end
-
-      def []=(key, value)
-        # only create a parameters field if a parameter is set; this will save
-        # bandwidth etc as most segments have no parameters
-        params[key] = value
-      end
-
-      def [](key)
-        params[key]
-      end
-
-      def params
-        @params ||= {}
-      end
-
-      def params=(p)
-        @params = p
-      end
-
-      # 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
-
-      # call the provided block for this segment and each
-      # of the called segments while keeping track of nested segments
-      def each_segment_with_nest_tracking(&block)
-        summary = block.call self
-        summary.current_nest_count += 1 if summary
-
-        if @called_segments
-          @called_segments.each do |segment|
-            segment.each_segment_with_nest_tracking(&block)
-          end
-        end
-
-        summary.current_nest_count -= 1 if summary
-      end
-
-      # This is only for use by developer mode
-      def find_segment(id)
-        return self if segment_id == id
-        called_segments.each do |segment|
-          found = segment.find_segment(id)
-          return found if found
-        end
-        nil
-      end
-
-      def explain_sql
-        return params[:explain_plan] if params.key?(:explain_plan)
-
-        statement = params[:sql]
-        return nil unless statement.respond_to?(:config) &&
-                          statement.respond_to?(:explainer)
-
-        NewRelic::Agent::Database.explain_sql(statement,
-                                              statement.config,
-                                              &statement.explainer)
-      end
-
-      def obfuscated_sql
-        NewRelic::Agent::Database.obfuscate_sql(params[:sql])
-      end
-
-      def called_segments=(segments)
-        @called_segments = segments
-      end
-
-      protected
-      def parent_segment=(s)
-        @parent_segment = s
-      end
-    end
-  end
-end