sundawg_newrelic_rpm 3.5.8.1

data/lib/new_relic/agent/stats.rb

@@ -0,0 +1,149 @@
+module NewRelic
+  module Agent
+    class Stats
+      attr_accessor :call_count
+      attr_accessor :min_call_time
+      attr_accessor :max_call_time
+      attr_accessor :total_call_time
+      attr_accessor :total_exclusive_time
+      attr_accessor :sum_of_squares
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @call_count = 0
+        @total_call_time = 0.0
+        @total_exclusive_time = 0.0
+        @min_call_time = 0.0
+        @max_call_time = 0.0
+        @sum_of_squares = 0.0
+      end
+
+      def is_reset?
+        call_count == 0 && total_call_time == 0.0 && total_exclusive_time == 0.0
+      end
+
+      def merge(other_stats)
+        stats = self.clone
+        stats.merge!(other_stats)
+      end
+
+      def merge!(other_stats)
+        Array(other_stats).each do |other|
+          @min_call_time = other.min_call_time if min_time_less?(other)
+          @max_call_time = other.max_call_time if other.max_call_time > max_call_time
+          @total_call_time      += other.total_call_time
+          @total_exclusive_time += other.total_exclusive_time
+          @sum_of_squares       += other.sum_of_squares
+          @call_count += other.call_count
+        end
+        self
+      end
+
+      def to_s
+        "[#{'%2i' % call_count.to_i} calls #{'%.4f' % total_call_time.to_f}s]"
+      end
+
+      def to_json(*_)
+        {
+          'call_count'           => call_count.to_i,
+          'min_call_time'        => min_call_time.to_f,
+          'max_call_time'        => max_call_time.to_f,
+          'total_call_time'      => total_call_time.to_f,
+          'total_exclusive_time' => total_exclusive_time.to_f,
+          'sum_of_squares'       => sum_of_squares.to_f
+        }.to_json(*_)
+      end
+
+      # record a single data point into the statistical gatherer.  The gatherer
+      # will aggregate all data points collected over a specified period and upload
+      # its data to the NewRelic server
+      def record_data_point(value, exclusive_time = value)
+        @call_count += 1
+        @total_call_time += value
+        @min_call_time = value if value < @min_call_time || @call_count == 1
+        @max_call_time = value if value > @max_call_time
+        @total_exclusive_time += exclusive_time
+
+        @sum_of_squares += (value * value)
+        self
+      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
+        @total_call_time += total_value
+        avg_val = total_value / count
+        @min_call_time = avg_val if avg_val < @min_call_time || @call_count == count
+        @max_call_time = avg_val if avg_val > @max_call_time
+        @total_exclusive_time += total_value
+        @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
+
+      def inspect
+        "#<NewRelic::Agent::Stats #{to_s} >"
+      end
+
+      def ==(other)
+        (
+          @min_call_time        == other.min_call_time &&
+          @max_call_time        == other.max_call_time &&
+          @total_call_time      == other.total_call_time &&
+          @total_exclusive_time == other.total_exclusive_time &&
+          @sum_of_squares       == other.sum_of_squares &&
+          @call_count           == other.call_count
+        )
+      end
+
+      # Apdex-related accessors
+      alias_method :apdex_s, :call_count
+      alias_method :apdex_t, :total_call_time
+      alias_method :apdex_f, :total_exclusive_time
+
+      def record_apdex_s
+        @call_count += 1
+      end
+
+      def record_apdex_t
+        @total_call_time += 1
+      end
+
+      def record_apdex_f
+        @total_exclusive_time += 1
+      end
+
+      protected
+
+      def min_time_less?(other)
+        (other.min_call_time < min_call_time && other.call_count > 0) || call_count == 0
+      end
+    end
+
+    class ChainedStats
+      attr_accessor :scoped_stats, :unscoped_stats
+
+      def initialize(scoped_stats, unscoped_stats)
+        @scoped_stats = scoped_stats
+        @unscoped_stats = unscoped_stats
+      end
+
+      def method_missing(method, *args)
+        unscoped_stats.send(method, *args)
+        scoped_stats.send(method, *args)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/stats_engine.rb

@@ -0,0 +1,30 @@
+require 'new_relic/agent/stats_engine/metric_stats'
+require 'new_relic/agent/stats_engine/samplers'
+require 'new_relic/agent/stats_engine/transactions'
+require 'new_relic/agent/stats_engine/gc_profiler'
+require 'new_relic/agent/stats_engine/stats_hash'
+
+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
+        @stats_lock = Mutex.new
+        @stats_hash = StatsHash.new
+        start_sampler_thread
+      end
+
+      # All access to the @stats_hash ivar should be funnelled through this
+      # method to ensure thread-safety. 
+      def with_stats_lock
+        @stats_lock.synchronize { yield }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+module NewRelic
+  module Agent
+    class StatsEngine
+      module GCProfiler
+        def self.init
+          @profiler = RailsBench.new if RailsBench.enabled?
+          @profiler = Ruby19.new if Ruby19.enabled?
+          @profiler = Rubinius.new if Rubinius.enabled?
+          @profiler
+        end
+
+        def self.capture
+          @profiler.capture if @profiler
+        end
+
+        class Profiler
+          def initialize
+            if self.class.enabled?
+              @last_timestamp = call_time
+              @last_count = call_count
+            end
+          end
+
+          def capture
+            return unless self.class.enabled?
+            return if !scope_stack.empty? && scope_stack.last.name == "GC/cumulative"
+
+            num_calls = call_count - @last_count
+            # microseconds to seconds
+            elapsed = (call_time - @last_timestamp).to_f / 1_000_000.0
+            @last_timestamp = call_time
+            @last_count = call_count
+            reset
+
+            record_gc_metric(num_calls, elapsed)
+            elapsed
+          end
+
+          def reset; end
+
+          protected
+
+          def record_gc_metric(num_calls, elapsed)
+            if num_calls > 0
+              # GC stats are collected into a blamed metric which allows
+              # us to show the stats controller by controller
+              gc_stats = NewRelic::Agent.instance.stats_engine \
+                .get_stats('GC/cumulative', true, false,
+                           NewRelic::Agent::TransactionInfo.get.transaction_name)
+              gc_stats.record_multiple_data_points(elapsed, num_calls)
+            end
+          end
+
+          def scope_stack
+            Thread::current[:newrelic_scope_stack] ||= []
+          end
+        end
+
+        class RailsBench < Profiler
+          def self.enabled?
+            ::GC.respond_to?(:time) && ::GC.respond_to?(:collections)
+          end
+
+          # microseconds spent in GC
+          def call_time
+            ::GC.time # this should already be microseconds
+          end
+
+          def call_count
+            ::GC.collections
+          end
+
+          def reset
+            ::GC.clear_stats
+          end
+        end
+
+        class Ruby19 < Profiler
+          def self.enabled?
+            defined?(::GC::Profiler) && ::GC::Profiler.enabled?
+          end
+
+          # microseconds spent in GC
+          # 1.9 total_time returns seconds.  Don't trust the docs.  It's seconds.
+          def call_time
+            ::GC::Profiler.total_time * 1_000_000.0 # convert seconds to microseconds
+          end
+
+          def call_count
+            ::GC.count
+          end
+
+          def reset
+            ::GC::Profiler.clear
+            @last_timestamp = 0
+          end
+        end
+
+        class Rubinius < Profiler
+          def self.enabled?
+            defined?(::Rubinius) && defined?(::Rubinius::GC) && ::Rubinius::GC.respond_to?(:count)
+          end
+
+          def call_time
+            ::Rubinius::GC.time * 1000
+          end
+
+          def call_count
+            ::Rubinius::GC.count
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+require 'new_relic/language_support'
+
+module NewRelic
+  module Agent
+    class StatsEngine
+      # Handles methods related to actual Metric collection
+      module MetricStats
+        # Lookup and write to the named metric in a single call.
+        #
+        # This method is thead-safe, and is preferred to the lookup / modify
+        # method pairs (e.g. get_stats + record_data_point)
+        def record_metric(metric_names_or_specs, value=nil, options={}, &blk)
+          defaults = {
+            :scoped => false,
+            :scope => default_scope
+          }
+          options = defaults.merge(options)
+          effective_scope = options[:scoped] && options[:scope]
+          specs = coerce_to_metric_spec_array(metric_names_or_specs, effective_scope)
+          with_stats_lock do
+            @stats_hash.record(specs, value, &blk)
+          end
+        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)
+          get_stats(metric_name, false)
+        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
+          stats = nil
+          with_stats_lock do
+            if scoped_metric_only
+              stats = @stats_hash[NewRelic::MetricSpec.new(metric_name, scope)]
+            else
+              unscoped_spec = NewRelic::MetricSpec.new(metric_name)
+              unscoped_stats = @stats_hash[unscoped_spec]
+              if scope && scope != metric_name
+                scoped_spec = NewRelic::MetricSpec.new(metric_name, scope)
+                scoped_stats = @stats_hash[scoped_spec]
+                stats = NewRelic::Agent::ChainedStats.new(scoped_stats, unscoped_stats)
+              else
+                stats = unscoped_stats
+              end
+            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 = '')
+          spec = NewRelic::MetricSpec.new(metric_name, scope_name)
+          with_stats_lock do
+            @stats_hash.has_key?(spec) ? @stats_hash[spec] : nil
+          end
+        end
+
+        # Helper method for timing supportability metrics
+        def record_supportability_metrics_timed(metrics)
+          start_time = Time.now
+          yield
+          end_time = Time.now
+          duration = (end_time - start_time).to_f
+        ensure
+          record_supportability_metrics(duration, metrics) do |value, metric|
+            metric.record_data_point(value)
+          end
+        end
+
+        # Helper for recording a straight value into the count
+        def record_supportability_metrics_count(value, *metrics)
+          record_supportability_metrics(value, *metrics) do |value, metric|
+            metric.call_count = value
+          end
+        end
+
+        # Helper method for recording supportability metrics consistently
+        def record_supportability_metrics(value, *metrics)
+          metrics.each do |metric|
+              yield(value, get_stats_no_scope("Supportability/#{metric}"))
+          end
+        end
+
+        def reset_stats
+          with_stats_lock do
+            old = @stats_hash
+            @stats_hash = StatsHash.new
+            old
+          end
+        end
+
+        # merge data from previous harvests into this stats engine
+        def merge!(other_stats_hash)
+          with_stats_lock do
+            @stats_hash.merge!(other_stats_hash)
+          end
+        end
+
+        # Harvest the timeslice data.  First recombine current statss
+        # with any previously
+        # unsent metrics, clear out stats cache, and return the current
+        # stats.
+        def harvest_timeslice_data(old_stats_hash, rules_engine=RulesEngine.new)
+          poll harvest_samplers
+          snapshot = reset_stats
+          snapshot = apply_rules_to_metric_data(rules_engine, snapshot)
+          snapshot.merge!(old_stats_hash)
+        end
+
+        def apply_rules_to_metric_data(rules_engine, stats_hash)
+          renamed_stats = NewRelic::Agent::StatsHash.new
+          stats_hash.each do |spec, stats|
+            new_name = rules_engine.rename(spec.name)
+            new_spec = NewRelic::MetricSpec.new(new_name, spec.scope)
+            renamed_stats[new_spec].merge!(stats)
+          end
+          renamed_stats
+        end
+
+        def default_scope
+          txn = NewRelic::Agent::TransactionInfo.get
+          txn.transaction_name_set? && txn.transaction_name
+        end
+
+        def coerce_to_metric_spec_array(metric_names_or_specs, scope)
+          specs = []
+          Array(metric_names_or_specs).map do |name_or_spec|
+            case name_or_spec
+            when String
+              specs << NewRelic::MetricSpec.new(name_or_spec)
+              specs << NewRelic::MetricSpec.new(name_or_spec, scope) if scope
+            when NewRelic::MetricSpec
+              specs << name_or_spec
+            end
+          end
+          specs
+        end
+
+        # For use by test code only.
+        def clear_stats
+          reset_stats
+          NewRelic::Agent::BusyCalculator.reset
+        end
+
+        # Returns all of the metric names of all the stats in the engine.
+        # For use by test code only.
+        def metrics
+          with_stats_lock do
+            @stats_hash.keys.map { |spec| spec.to_s }
+          end
+        end
+      end
+    end
+  end
+end