dolores_rpm 3.2.0.2

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

@@ -0,0 +1,187 @@
+require 'new_relic/language_support'
+
+module NewRelic
+  module Agent
+    class StatsEngine
+      # Handles methods related to actual Metric collection
+      module MetricStats
+        # A simple mutex-synchronized hash to make sure our statistics
+        # are internally consistent even in truly-threaded rubies like JRuby
+        class SynchronizedHash < ::Hash
+          include NewRelic::LanguageSupport::SynchronizedHash
+          
+          def initialize
+            @lock = Mutex.new
+          end
+          
+          def []=(*args)
+            @lock.synchronize { super }
+          end
+
+          def clear(*args)
+            @lock.synchronize { super }
+          end
+
+          def delete(*args)
+            @lock.synchronize { super }
+          end
+
+          def delete_if(*args)
+            @lock.synchronize { super }
+          end
+        end
+        
+        # Returns all of the metric names of all the stats in the engine
+        def metrics
+          stats_hash.keys.map(&:to_s)
+        end
+        
+        # a simple accessor for looking up a stat with no scope -
+        # returns a new stats object if no stats object for that
+        # metric exists yet
+        def get_stats_no_scope(metric_name)
+          stats_hash[NewRelic::MetricSpec.new(metric_name, '')] ||= NewRelic::MethodTraceStats.new
+        end
+
+        # This version allows a caller to pass a stat class to use
+        def get_custom_stats(metric_name, stat_class)
+          stats_hash[NewRelic::MetricSpec.new(metric_name)] ||= stat_class.new
+        end
+
+        # If use_scope is true, two chained metrics are created, one with scope and one without
+        # If scoped_metric_only is true, only a scoped metric is created (used by rendering metrics which by definition are per controller only)
+        def get_stats(metric_name, use_scope = true, scoped_metric_only = false, scope = nil)
+          scope ||= scope_name if use_scope
+          if scoped_metric_only
+            spec = NewRelic::MetricSpec.new metric_name, scope
+            stats = stats_hash[spec] ||= NewRelic::MethodTraceStats.new
+          else
+            stats = stats_hash[NewRelic::MetricSpec.new(metric_name)] ||= NewRelic::MethodTraceStats.new
+            if scope && scope != metric_name
+              spec = NewRelic::MetricSpec.new metric_name, scope
+              stats = stats_hash[spec] ||= NewRelic::ScopedMethodTraceStats.new(stats)
+            end
+          end
+          stats
+        end
+        
+        # Returns a stat if one exists, otherwise returns nil. If you
+        # want auto-initialization, use one of get_stats or get_stats_no_scope
+        def lookup_stats(metric_name, scope_name = '')
+          stats_hash[NewRelic::MetricSpec.new(metric_name, scope_name)]
+        end
+        
+        # This module was extracted from the harvest method and should
+        # be refactored
+        module Harvest
+          
+          # merge data from previous harvests into this stats engine -
+          # takes into account the case where there are new stats for
+          # that metric, and the case where there is no current data
+          # for that metric
+          def merge_data(metric_data_hash)
+            metric_data_hash.each do |metric_spec, metric_data|
+              new_data = lookup_stats(metric_spec.name, metric_spec.scope)
+              if new_data
+                new_data.merge!(metric_data.stats)
+              else
+                stats_hash[metric_spec] = metric_data.stats
+              end
+            end
+          end
+
+          private
+          def get_stats_hash_from(engine_or_hash)
+            if engine_or_hash.is_a?(StatsEngine)
+              engine_or_hash.stats_hash
+            else
+              engine_or_hash
+            end
+          end
+
+          def coerce_to_metric_spec(metric_spec)
+            if metric_spec.is_a?(NewRelic::MetricSpec)
+              metric_spec
+            else
+              NewRelic::MetricSpec.new(metric_spec)
+            end
+          end
+
+          def clone_and_reset_stats(metric_spec, stats)
+            if stats.nil?
+              raise "Nil stats for #{metric_spec.name} (#{metric_spec.scope})"
+            end
+
+            stats_copy = stats.clone
+            stats.reset
+            stats_copy
+          end
+
+          # if the previous timeslice data has not been reported (due to an error of some sort)
+          # then we need to merge this timeslice with the previously accumulated - but not sent
+          # data
+          def merge_old_data!(metric_spec, stats, old_data)
+            metric_data = old_data[metric_spec]
+            stats.merge!(metric_data.stats) unless metric_data.nil?
+          end
+
+          def add_data_to_send_unless_empty(data, stats, metric_spec, id)
+            # don't bother collecting and reporting stats that have
+            # zero-values for this timeslice. significant
+            # performance boost and storage savings.
+            return if stats.is_reset?
+            data[metric_spec] = NewRelic::MetricData.new((id ? nil : metric_spec), stats, id)
+          end
+
+          def merge_stats(other_engine_or_hash, metric_ids)
+            old_data = get_stats_hash_from(other_engine_or_hash)
+
+            timeslice_data = {}
+            stats_hash.each do | metric_spec, stats |
+
+              metric_spec = coerce_to_metric_spec(metric_spec)
+              stats_copy = clone_and_reset_stats(metric_spec, stats)
+              merge_old_data!(metric_spec, stats_copy, old_data)
+              add_data_to_send_unless_empty(timeslice_data, stats_copy, metric_spec, metric_ids[metric_spec])
+            end
+            timeslice_data
+          end
+
+        end
+        include Harvest
+
+        # Harvest the timeslice data.  First recombine current statss
+        # with any previously
+        # unsent metrics, clear out stats cache, and return the current
+        # stats.
+        # ---
+        # Note: this is not synchronized.  There is still some risk in this and
+        # we will revisit later to see if we can make this more robust without
+        # sacrificing efficiency.
+        # +++
+        def harvest_timeslice_data(previous_timeslice_data, metric_ids)
+
+          poll harvest_samplers
+          merge_stats(previous_timeslice_data, metric_ids)
+        end
+
+        # Remove all stats.  For test code only.
+        def clear_stats
+          @stats_hash = SynchronizedHash.new
+          NewRelic::Agent::BusyCalculator.reset
+        end
+
+        # Reset each of the stats, such as when a new passenger instance starts up.
+        def reset_stats
+          stats_hash.values.each { |s| s.reset }
+        end
+        
+        # returns a memoized SynchronizedHash that holds the actual
+        # instances of Stats keyed off their MetricName
+        def stats_hash
+          @stats_hash ||= SynchronizedHash.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module NewRelic
+module Agent
+  class StatsEngine
+    module Shim # :nodoc:
+      def add_sampler(*args); end
+      def add_harvest_sampler(*args); end
+      def start_sampler_thread(*args); end
+    end
+    
+    # Contains statistics engine extensions to support the concept of samplers
+    module Samplers
+
+      # By default a sampler polls on harvest time, once a minute.  However you can
+      # override #use_harvest_sampler? to return false and it will sample
+      # every POLL_PERIOD seconds on a background thread.
+      POLL_PERIOD = 20
+      
+      # starts the sampler thread which runs periodically, rather than
+      # at harvest time. This is deprecated, and should not actually
+      # be used - mo threads mo problems
+      #
+      # returns unless there are actually periodic samplers to run
+      def start_sampler_thread
+
+        return if @sampler_thread && @sampler_thread.alive?
+
+        # start up a thread that will periodically poll for metric samples
+        return if periodic_samplers.empty?
+
+        @sampler_thread = Thread.new do
+          while true do
+            begin
+              sleep POLL_PERIOD
+              poll periodic_samplers
+            end
+          end
+        end
+        @sampler_thread['newrelic_label'] = 'Sampler Tasks'
+      end
+
+      private
+
+      def add_sampler_to(sampler_array, sampler)
+        raise "Sampler #{sampler.inspect} is already registered.  Don't call add_sampler directly anymore." if sampler_array.include?(sampler)
+        sampler_array << sampler
+        sampler.stats_engine = self
+      end
+
+      def log_added_sampler(type, sampler)
+        log.debug "Adding #{type} sampler: #{sampler.inspect}"
+      end
+
+      public
+
+      # Add an instance of Sampler to be invoked about every 10 seconds on a background
+      # thread.
+      def add_sampler(sampler)
+        add_sampler_to(periodic_samplers, sampler)
+        log_added_sampler('periodic', sampler)
+      end
+
+      # Add a sampler to be invoked just before each harvest.
+      def add_harvest_sampler(sampler)
+        add_sampler_to(harvest_samplers, sampler)
+        log_added_sampler('harvest-time', sampler)
+      end
+
+      private
+
+      # Call poll on each of the samplers.  Remove
+      # the sampler if it raises.
+      def poll(samplers)
+        samplers.delete_if do |sampled_item|
+          begin
+            sampled_item.poll
+            false # it's okay.  don't delete it.
+          rescue Exception => e
+            log.error "Removing #{sampled_item} from list"
+            log.error e
+            log.debug e.backtrace.to_s
+            true # remove the sampler
+          end
+        end
+      end
+
+      def harvest_samplers
+        @harvest_samplers ||= []
+      end
+      def periodic_samplers
+        @periodic_samplers ||= []
+      end
+    end
+  end
+end
+end

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

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+module NewRelic
+module Agent
+  class StatsEngine
+    # A simple stack element that tracks the current name and length
+    # of the executing stack
+    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
+    
+    # Handles pushing and popping elements onto an internal stack that
+    # tracks where time should be allocated in Transaction Traces
+    module Transactions
+      
+      # Defines methods that stub out the stats engine methods
+      # when the agent is disabled
+      module Shim # :nodoc:
+        def start_transaction(*args); end
+        def end_transaction; end
+        def push_scope(*args); end
+        def transaction_sampler=(*args); end
+        def sql_sampler=(*args); end
+        def scope_name=(*args); end
+        def scope_name; end
+        def pop_scope(*args); end
+      end
+      
+      # 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
+      
+      def sql_sampler= sampler
+        fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
+        @sql_sampler = sampler
+      end
+
+      def remove_sql_sampler(l)
+        @sql_sampler = nil
+      end
+
+      # Pushes a scope onto the transaction stack - this generates a
+      # TransactionSample::Segment at the end of transaction execution
+      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
+        @transaction_sampler.notice_push_scope metric, time if @transaction_sampler
+        scope = ScopeStackElement.new(metric, deduct_call_time_from_parent)
+        stack.push scope
+        scope
+      end
+      
+      # Pops a scope off the transaction stack - this updates the
+      # transaction sampler that we've finished execution of a traced method
+      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, got #{scope ? scope.name : 'nil'}, expected #{expected_scope ? expected_scope.name : 'nil'}" 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
+        @transaction_sampler.notice_pop_scope(scope.name, time) if @transaction_sampler
+        scope
+      end
+      
+      # Returns the latest ScopeStackElement
+      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 scope_name=(transaction)
+        Thread::current[:newrelic_scope_name] = transaction
+        Thread::current[:newrelic_most_recent_transaction] = transaction
+      end
+      
+      # Returns the current scope name from the thread local
+      def scope_name
+        Thread::current[:newrelic_scope_name]
+      end
+
+      # Start a new transaction, unless one is already in progress
+      def start_transaction(name = nil)
+        Thread::current[:newrelic_scope_stack] ||= []
+        self.scope_name = name if name
+      end
+
+      # Try to clean up gracefully, otherwise we leave things hanging around on thread locals.
+      # If it looks like a transaction is still in progress, then maybe this is an inner transaction
+      # and is ignored.
+      #
+      def end_transaction
+        stack = scope_stack
+
+        if stack && stack.empty?
+          Thread::current[:newrelic_scope_stack] = nil
+          Thread::current[:newrelic_scope_name] = nil
+        end
+      end
+
+      private
+
+      # Make sure we don't do this in a multi-threaded environment
+      def collecting_gc?
+        if !defined?(@@collecting_gc)
+          @@collecting_gc = false
+          if !NewRelic::Control.instance.multi_threaded?
+            @@collecting_gc = true if GC.respond_to?(:time) && GC.respond_to?(:collections) # 1.8.x
+            @@collecting_gc = true if defined?(GC::Profiler) && GC::Profiler.enabled? # 1.9.2
+          end
+        end
+        @@collecting_gc
+      end
+
+      # The total number of times the garbage collector has run since
+      # profiling was enabled
+      def gc_collections
+        if GC.respond_to?(:count)
+          GC.count
+        elsif GC.respond_to?(:collections)
+          GC.collections
+        end
+      end
+
+      # The total amount of time taken by garbage collection since
+      # profiling was enabled
+      def gc_time
+        if GC.respond_to?(:time)
+          GC.time
+        elsif defined?(GC::Profiler) && GC::Profiler.respond_to?(:total_time)
+          # The 1.9 profiler returns a time in usec
+          GC::Profiler.total_time * 1000000.0
+        end
+      end
+
+      # 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).to_f
+        @last_gc_timestamp = gc_time
+        @last_gc_count = gc_collections
+        
+        if defined?(GC::Profiler)
+          GC::Profiler.clear
+          @last_gc_timestamp = 0
+        end
+        
+        if num_calls > 0
+          # µ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, elapsed, time)
+        end
+      end
+      
+      # Returns the current scope stack, memoized to a thread local variable
+      def scope_stack
+        Thread::current[:newrelic_scope_stack] ||= []
+      end
+
+    end
+  end
+end
+end

data/lib/new_relic/agent/stats_engine.rb

@@ -0,0 +1,25 @@
+require 'new_relic/agent/stats_engine/metric_stats'
+require 'new_relic/agent/stats_engine/samplers'
+require 'new_relic/agent/stats_engine/transactions'
+
+module NewRelic
+  module Agent
+    # This class handles all the statistics gathering for the agent
+    class StatsEngine
+      include MetricStats
+      include Samplers
+      include Transactions
+
+      def initialize
+        # Makes the unit tests happy
+        Thread::current[:newrelic_scope_stack] = nil
+        start_sampler_thread
+      end
+
+      def log
+        NewRelic::Control.instance.log
+      end
+
+    end
+  end
+end

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -0,0 +1,101 @@
+require 'new_relic/collection_helper'
+require 'new_relic/transaction_sample'
+require 'new_relic/control'
+require 'new_relic/agent/instrumentation/metric_frame'
+module NewRelic
+  module Agent
+    # 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, :sample
+
+      include NewRelic::CollectionHelper
+
+      def initialize(time=Time.now)
+        @sample = NewRelic::TransactionSample.new(time.to_f)
+        @sample_start = time.to_f
+        @current_segment = @sample.root_segment
+      end
+
+      def sample_id
+        @sample.sample_id
+      end
+      def ignored?
+        @ignore || @sample.params[:path].nil?
+      end
+      def ignore_transaction
+        @ignore = true
+      end
+      def trace_entry(metric_name, time)
+        segment = @sample.create_segment(time.to_f - @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.to_f - @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.error "Unexpected double-freeze of Transaction Trace Object: \n#{@sample.to_s}"
+          return
+        end
+        @sample.root_segment.end_trace(time.to_f - @sample_start)
+        @sample.params[:custom_params] = normalize_params(NewRelic::Agent::Instrumentation::MetricFrame.custom_parameters)
+        @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_profile(profile)
+        @sample.profile = profile
+      end
+
+      def set_transaction_info(path, uri, 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] ||= uri || params[:uri]
+      end
+
+      def set_transaction_cpu_time(cpu_time)
+        @sample.params[:cpu_time] = cpu_time
+      end
+
+      def sample
+        @sample
+      end
+
+    end
+  end
+end