newrelic_rpm 3.6.2.96 → 3.6.3.103.beta

data/lib/new_relic/agent/request_sampler.rb

@@ -0,0 +1,205 @@
+# -*- ruby -*-
+# 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 'monitor'
+
+require 'newrelic_rpm' unless defined?( NewRelic )
+require 'new_relic/agent' unless defined?( NewRelic::Agent )
+
+class NewRelic::Agent::RequestSampler
+  include NewRelic::Coerce,
+          MonitorMixin
+
+  # The amount of time between samples, in milliseconds
+  DEFAULT_SAMPLE_RATE_MS   = 50
+
+  # The minimum amount of time between samples, in milliseconds
+  MIN_SAMPLE_RATE_MS       = 25
+
+  # The number of seconds between harvests
+  # :TODO: Get this from the agent instead?
+  DEFAULT_REPORT_FREQUENCY = 60
+
+  # The namespace and keys of config values
+  CONFIG_NAMESPACE = 'request_sampler'
+  SAMPLE_RATE_KEY  = "#{CONFIG_NAMESPACE}.sample_rate_ms".to_sym
+  ENABLED_KEY      = "#{CONFIG_NAMESPACE}.enabled".to_sym
+
+  # The type field of the sample
+  SAMPLE_TYPE              = 'Transaction'
+
+  # Strings for static keys of the sample structure
+  TYPE_KEY                 = 'type'
+  TIMESTAMP_KEY            = 'timestamp'
+  NAME_KEY                 = 'name'
+  DURATION_KEY             = 'duration'
+
+
+  # Create a new RequestSampler that will keep samples added to it every
+  # +sample_rate_ms+ milliseconds.
+  def initialize( event_listener )
+    super()
+
+    @enabled               = false
+    @sample_rate_ms        = DEFAULT_SAMPLE_RATE_MS
+    @normal_sample_rate_ms = @sample_rate_ms
+    @last_sample_taken     = nil
+    @last_harvest          = nil
+    @samples               = []
+
+    event_listener.subscribe( :transaction_finished, &method(:on_transaction_finished) )
+    self.register_config_callbacks
+  end
+
+
+  ######
+  public
+  ######
+
+  # The sample rate, in milliseconds between samples, that the sampler uses
+  # under normal circumstances
+  attr_reader :normal_sample_rate_ms
+
+  # The current sample rate, which may be different from the #normal_sample_rate_ms
+  # if the sampler is throttled.
+  attr_reader :sample_rate_ms
+
+  # The Time when the last sample was kept
+  attr_reader :last_sample_taken
+
+
+  ### Fetch a copy of the sampler's gathered samples. (Synchronized)
+  def samples
+    return self.synchronize { @samples.dup }
+  end
+
+
+  # Clear any existing samples and reset the last sample time. (Synchronized)
+  def reset
+    NewRelic::Agent.logger.debug "Resetting RequestSampler"
+
+    self.synchronize do
+      @samples.clear
+      @sample_rate_ms = @normal_sample_rate_ms
+      @last_sample_taken = Time.now
+    end
+  end
+
+
+  #
+  # :group: Event handlers
+  #
+
+  def register_config_callbacks
+    NewRelic::Agent.config.register_callback(SAMPLE_RATE_KEY) do |rate_ms|
+      NewRelic::Agent.logger.debug "RequestSampler sample rate to %dms" % [ rate_ms ]
+
+      if rate_ms < MIN_SAMPLE_RATE_MS
+        NewRelic::Agent.logger.warn "  limiting RequestSampler frequency to %dms (was %dms)" %
+          [ MIN_SAMPLE_RATE_MS, rate_ms ]
+        rate_ms = MIN_SAMPLE_RATE_MS
+      end
+
+      @normal_sample_rate_ms = rate_ms
+      self.reset
+    end
+
+    NewRelic::Agent.config.register_callback(ENABLED_KEY) do |enabled|
+      NewRelic::Agent.logger.info "%sabling the Request Sampler." % [ enabled ? 'En' : 'Dis' ]
+      @enabled = enabled
+    end
+  end
+
+
+  # Event handler for the :transaction_finished event.
+  def on_transaction_finished( metric, duration, options={} )
+    return unless @enabled
+    self << {
+      NAME_KEY     => string(metric),
+      DURATION_KEY => float(duration)
+    }.merge(options)
+  end
+
+
+
+  #
+  # :group: Sample API
+  # These methods are synchronized.
+  #
+
+  # Add a datapoint to the sampler if a sample is due. The +sample+ should be
+  # of the form:
+  #
+  #   {
+  #     'name' => '<transaction/metric name>',
+  #     'duration' => <duration in seconds as a Float>,
+  #   }
+  #
+  # This method is synchronized.
+  def <<( sample )
+    self.synchronize do
+      self.add_sample( sample ) if should_sample?
+    end
+
+    return self
+  end
+
+
+  # Downsample the gathered data and reduce the sampling rate to conserve memory. The amount
+  # the sampler is throttled is proportional to +resolution+, which defaults to the number of
+  # normal report periods which have elapsed. E.g., if three sessions with the agent have failed,
+  # the sampler downsamples its data to include one out of even three samples, and only samples
+  # a third of the time it normally would.
+  #
+  # This method is synchronized.
+  def throttle( resolution=nil )
+
+    # Only throttle if the sampler was running
+    self.synchronize do
+      if @last_sample_taken && !@samples.empty?
+        resolution ||= (Time.now - @last_sample_taken) / DEFAULT_REPORT_FREQUENCY
+        @sample_rate_ms = @normal_sample_rate_ms * resolution
+        self.downsample_data( resolution )
+      end
+    end
+
+    if resolution
+      NewRelic::Agent.logger.debug "  resolution is now: %d -> 1 sample every %dms" %
+        [ resolution, @sample_rate_ms ]
+    end
+  end
+
+
+  #########
+  protected
+  #########
+
+  # Returns +true+ if a sample added now should be kept based on the sample
+  # frequency.
+  def should_sample?
+    return false unless @last_sample_taken
+    return ((Time.now - @last_sample_taken) * 1000).ceil >= @sample_rate_ms
+  end
+
+
+  # Add the given +sample+ to the sampler (unconditionally).
+  def add_sample( sample )
+    @last_sample_taken = Time.now
+
+    sample[TYPE_KEY]      = SAMPLE_TYPE
+    sample[TIMESTAMP_KEY] = @last_sample_taken
+
+    @samples << sample
+  end
+
+
+  # Downsample the current data to match the specified +resolution+.
+  def downsample_data( resolution )
+    goalsize = @samples.length * ( (resolution - 1) / resolution.to_f )
+    0.step( goalsize.ceil, resolution - 1 ) {|i| @samples.slice!(i+1) }
+  end
+
+end # class NewRelic::Agent::RequestSampler
+

data/lib/new_relic/agent/sampler.rb

@@ -17,7 +17,6 @@ module NewRelic
       # Exception denotes a sampler is not available and it will not be registered.
       class Unsupported < StandardError;  end
 
-      attr_accessor :stats_engine
       attr_reader :id
       @sampler_classes = []
 

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

@@ -77,7 +77,6 @@ module Agent
           NewRelic::Agent.logger.warn "Ignoring addition of #{sampler.inspect} because it is already registered."
         else
           sampler_array << sampler
-          sampler.stats_engine = self
         end
       end
 

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

@@ -34,19 +34,6 @@ module Agent
         def pop_scope(*args); end
       end
 
-      attr_reader :transaction_sampler
-
-      # add a new transaction sampler, unless we're currently in a
-      # transaction (then we fail)
-      def transaction_sampler= sampler
-        fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
-        @transaction_sampler = sampler
-      end
-
-      # removes a transaction sampler
-      def remove_transaction_sampler(l)
-        @transaction_sampler = nil
-      end
 
       # Pushes a scope onto the transaction stack - this generates a
       # TransactionSample::Segment at the end of transaction execution
@@ -56,7 +43,7 @@ module Agent
       # identify this scope if the stack gets corrupted.
       def push_scope(tag, time = Time.now.to_f, deduct_call_time_from_parent = true)
         stack = scope_stack
-        @transaction_sampler.notice_push_scope(time) if sampler_enabled?
+        transaction_sampler.notice_push_scope(time) if sampler_enabled?
         scope = ScopeStackElement.new(tag, time, deduct_call_time_from_parent)
         stack.push scope
         scope
@@ -80,13 +67,22 @@ module Agent
             stack.last.children_time += scope.children_time
           end
         end
-        @transaction_sampler.notice_pop_scope(name, time) if sampler_enabled?
+        transaction_sampler.notice_pop_scope(name, time) if sampler_enabled?
         scope.name = name
         scope
       end
 
       def sampler_enabled?
-        @transaction_sampler && Agent.config[:'transaction_tracer.enabled']
+        Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
+      end
+
+      def transaction_sampler
+        Agent.instance.transaction_sampler
+      end
+
+      # deprecated--used to add transaction sampler, now we always look to the agent
+      def transaction_sampler= sampler
+        NewRelic::Agent.logger.warn("NewRelic::Agent::StatsEngine#transaction_sampler is deprecated")
       end
 
       # set the name of the transaction for the current thread, which will be used

data/lib/new_relic/agent/transaction.rb

@@ -43,9 +43,9 @@ module NewRelic
         return txn
       end
 
-      def self.stop(metric_name=nil)
+      def self.stop(metric_name=nil, end_time=Time.now)
         txn = self.stack.pop
-        txn.stop(metric_name) if txn
+        txn.stop(metric_name, end_time) if txn
         return txn
       end
 
@@ -105,7 +105,7 @@ module NewRelic
         if !@name_frozen
           @name = name
         else
-          NewRelic::Agent.logger.warn("Attempted to rename transaction to #{name} after transaction name was already frozen.")
+          NewRelic::Agent.logger.warn("Attempted to rename transaction to '#{name}' after transaction name was already frozen as '#{@name}'.")
         end
       end
 
@@ -157,9 +157,10 @@ module NewRelic
         transaction_sampler.ignore_transaction
       end
 
+
       # Unwind one stack level.  It knows if it's back at the outermost caller and
       # does the appropriate wrapup of the context.
-      def stop(metric=::NewRelic::Agent::UNKNOWN_METRIC)
+      def stop(metric=::NewRelic::Agent::UNKNOWN_METRIC, end_time=Time.now)
         @name ||= metric unless name_frozen?
         freeze_name
         log_underflow if @type.nil?
@@ -175,6 +176,7 @@ module NewRelic
           end
           @transaction_trace = transaction_sampler.notice_scope_empty(self, Time.now, gc_time)
           sql_sampler.notice_scope_empty(@name)
+          overview_metrics = transaction_overview_metrics
         end
 
         record_exceptions
@@ -183,6 +185,7 @@ module NewRelic
         # these tear everything down so need to be done
         # after the pop
         if self.class.stack.empty?
+          agent.events.notify(:transaction_finished, @name, end_time.to_f - start_time.to_f, overview_metrics)
           agent.stats_engine.end_transaction
         end
       end
@@ -194,6 +197,24 @@ module NewRelic
         end
       end
 
+      OVERVIEW_SPECS = [
+        [:web_duration,      MetricSpec.new('HttpDispatcher')],
+        [:queue_duration,    MetricSpec.new('WebFrontend/QueueTime')],
+        [:external_duration, MetricSpec.new('External/allWeb')],
+        [:database_duration, MetricSpec.new('ActiveRecord/all')],
+        [:gc_cumulative,     MetricSpec.new("GC/cumulative")],
+        [:memcache_duration, MetricSpec.new('Memcache/allWeb')]
+      ]
+
+      def transaction_overview_metrics
+        metrics = {}
+        stats = agent.stats_engine.transaction_stats_hash
+        OVERVIEW_SPECS.each do |(dest_key, spec)|
+          metrics[dest_key] = stats[spec].total_call_time if stats.key?(spec)
+        end
+        metrics
+      end
+
       # If we have an active transaction, notice the error and increment the error metric.
       # Options:
       # * <tt>:request</tt> => Request object to get the uri and referer
@@ -299,6 +320,8 @@ module NewRelic
         user_attributes.merge!(attributes)
       end
 
+      # Returns truthy if the current in-progress transaction is considered a
+      # a web transaction (as opposed to, e.g., a background transaction).
       def self.recording_web_transaction?
         self.current && self.current.recording_web_transaction?
       end

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -11,7 +11,36 @@ module NewRelic
     # 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.
+    #
+    # @api private
     class TransactionSampleBuilder
+
+      # Once we hit the TT segment limit, we use this class to hold our place in
+      # the tree so that we can still get accurate names and times on the
+      # segments we've already created. The placeholder segment keeps a
+      # depth counter that's incremented on each segment entry, and decremented
+      # on exit, until it reaches zero, when we throw the placeholder away.
+      # There should only ever be zero or one placeholder segment at a time.
+      #
+      # @api private
+      class PlaceholderSegment
+        attr_reader :parent_segment
+        attr_accessor :depth
+
+        def initialize(parent_segment)
+          @parent_segment = parent_segment
+          @depth = 1
+        end
+
+        # No-op - some clients expect to be able to use this to attach params to
+        # TT segments.
+        def []=(key, value); end
+
+        # No-op - some clients expect to be able to use this to read params from
+        # TT segments.
+        def [](key); end
+      end
+
       attr_reader :current_segment, :sample
 
       include NewRelic::CollectionHelper
@@ -39,22 +68,34 @@ module NewRelic
       end
 
       def trace_entry(time)
-        if @sample.count_segments < segment_limit()
+        if @sample.count_segments < segment_limit
           segment = @sample.create_segment(time.to_f - @sample_start)
           @current_segment.add_called_segment(segment)
           @current_segment = segment
           if @sample.count_segments == segment_limit()
             ::NewRelic::Agent.logger.debug("Segment limit of #{segment_limit} reached, ceasing collection.")
           end
-          @current_segment
+        else
+          if @current_segment.is_a?(PlaceholderSegment)
+            @current_segment.depth += 1
+          else
+            @current_segment = PlaceholderSegment.new(@current_segment)
+          end
         end
+        @current_segment
       end
 
       def trace_exit(metric_name, time)
-        return unless @sample.count_segments < segment_limit()
-        @current_segment.metric_name = metric_name
-        @current_segment.end_trace(time.to_f - @sample_start)
-        @current_segment = @current_segment.parent_segment
+        if @current_segment.is_a?(PlaceholderSegment)
+          @current_segment.depth -= 1
+          if @current_segment.depth == 0
+            @current_segment = @current_segment.parent_segment
+          end
+        else
+          @current_segment.metric_name = metric_name
+          @current_segment.end_trace(time.to_f - @sample_start)
+          @current_segment = @current_segment.parent_segment
+        end
       end
 
       def finish_trace(time=Time.now.to_f, custom_params={})

data/lib/new_relic/agent/transaction_sampler.rb

@@ -400,12 +400,7 @@ module NewRelic
         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(Agent.config[:'transaction_tracer.limit_segments']) }
         result
       end