newrelic_rpm 3.5.7.59 → 3.5.8.64.beta

data/lib/new_relic/agent/shim_agent.rb

@@ -18,7 +18,6 @@ module NewRelic
       def after_fork *args; end
       def start *args; end
       def shutdown *args; end
-      def serialize; end
       def merge_data_from *args; end
       def push_trace_execution_flag *args; end
       def pop_trace_execution_flag *args; end

data/lib/new_relic/agent/sql_sampler.rb

@@ -99,7 +99,8 @@ module NewRelic
         if NewRelic::Agent.is_sql_recorded?
           if duration > Agent.config[:'slow_sql.explain_threshold']
             backtrace = caller.join("\n")
-            transaction_data.sql_data << SlowSql.new(sql, metric_name, config,
+            transaction_data.sql_data << SlowSql.new(TransactionSampler.truncate_message(sql),
+                                                     metric_name, config,
                                                      duration, backtrace)
           end
         end
@@ -176,7 +177,7 @@ module NewRelic
       end
     end
 
-    class SqlTrace < MethodTraceStats
+    class SqlTrace < Stats
       attr_reader :path
       attr_reader :url
       attr_reader :sql_id

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

@@ -2,6 +2,7 @@ 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
@@ -14,8 +15,16 @@ module NewRelic
       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

@@ -7,7 +7,7 @@ module NewRelic
           @profiler = RailsBench.new if RailsBench.enabled?
           @profiler = Ruby19.new if Ruby19.enabled?
           @profiler = Rubinius.new if Rubinius.enabled?
-          @profiler = RubiniusAgent.new if RubiniusAgent.enabled?
+          @profiler
         end
 
         def self.capture
@@ -110,29 +110,6 @@ module NewRelic
             ::Rubinius::GC.count
           end
         end
-
-        class RubiniusAgent < Profiler
-          def self.enabled?
-            if NewRelic::LanguageSupport.using_engine?('rbx')
-              require 'rubinius/agent'
-              true
-            else
-              false
-            end
-          end
-
-          def call_time
-            agent = ::Rubinius::Agent.loopback
-            (agent.get('system.gc.young.total_wallclock')[1] +
-              agent.get('system.gc.full.total_wallclock')[1]) * 1000
-          end
-
-          def call_count
-            agent = ::Rubinius::Agent.loopback
-            agent.get('system.gc.young.count')[1] +
-              agent.get('system.gc.full.count')[1]
-          end
-        end
       end
     end
   end

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

@@ -5,109 +5,48 @@ module NewRelic
     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
-          attr_reader :lock
-
-          def initialize
-            @lock = Mutex.new
-          end
-
-          def initialize_copy(old)
-            super
-            old.each do |key, value|
-              self.store(key, value.dup)
-            end
-          end
-
-          def []=(*args)
-            @lock.synchronize { super }
-          rescue => e
-            log_error(e)
-          end
-
-          def clear(*args)
-            @lock.synchronize { super }
-          rescue => e
-            log_error(e)
-          end
-
-          def delete(*args)
-            @lock.synchronize { super }
-          rescue => e
-            log_error(e)
-          end
-
-          def delete_if(*args)
-            @lock.synchronize { super }
-          rescue => e
-            log_error(e)
-          end
-
-          def reset
-            values.each { |s| s.reset }
-          end
-
-          def log_error(e)
-            backtraces = Thread.list.map { |t| log_thread(t) }.join("\n\n")
-            ::NewRelic::Agent.logger.warn(
-              "SynchronizedHash failure: #{e.class.name}: #{e.message}\n#{backtraces}")
-          end
-
-          def log_thread(t)
-            # Ruby 1.8 doesn't expose backtrace properly, so make sure it's there
-            if t.nil? || !t.respond_to?(:backtrace) || t.backtrace.nil?
-              return "#{t}\n\tNo backtrace for thread" 
-            end
-
-            backtrace = t.backtrace.map { |b| "\t#{b}" }.join("\n")
-            "\t#{t}\n#{backtrace}"
-
-          rescue Exception => e
-            # JRuby 1.7.0 has a nasty habit of raising a
-            # java.lang.NullPointerException when we iterate through threads
-            # asking for backtraces.  This line allows us to swallow java
-            # exceptions without referencing their classes (since they don't
-            # exist in MRI).  It also prevents us from swallowing signals or
-            # other nasty things that can happen when you rescue Exception.
-            ::NewRelic::Agent.logger.warn(
-              "Error collecting thread backtraces: #{e.class.name}: #{e.message}")
-            ::NewRelic::Agent.logger.debug( e.backtrace.join("\n") )
-
-            raise e if e.class.ancestors.include? Exception
+        # 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
 
-        # 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
+          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
-          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)
+          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
@@ -116,10 +55,12 @@ module NewRelic
         # 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)]
+          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
@@ -146,115 +87,73 @@ module NewRelic
           end
         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?
+        def reset_stats
+          with_stats_lock do
+            old = @stats_hash
+            @stats_hash = StatsHash.new
+            old
           end
+        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)
+        # 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
-
-          def merge_stats(other_engine_or_hash, metric_ids)
-            old_data = get_stats_hash_from(other_engine_or_hash)
-            timeslice_data = {}
-            stats_hash.lock.synchronize do
-              Thread.current['newrelic_stats_hash'] = stats_hash.clone
-              stats_hash.reset
-            end
-            Thread.current['newrelic_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)
+        def harvest_timeslice_data(old_stats_hash, rules_engine=RulesEngine.new)
           poll harvest_samplers
-          merge_stats(previous_timeslice_data, metric_ids)
+          snapshot = reset_stats
+          snapshot = apply_rules_to_metric_data(rules_engine, snapshot)
+          snapshot.merge!(old_stats_hash)
         end
 
-        # Remove all stats.  For test code only.
-        def clear_stats
-          @stats_hash = SynchronizedHash.new
-          NewRelic::Agent::BusyCalculator.reset
+        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
 
-        # Reset each of the stats, such as when a new passenger instance starts up.
-        def reset_stats
-          stats_hash.reset
+        def default_scope
+          txn = NewRelic::Agent::TransactionInfo.get
+          txn.transaction_name_set? && txn.transaction_name
         end
 
-        # returns a memoized SynchronizedHash that holds the actual
-        # instances of Stats keyed off their MetricName
-        def stats_hash
-          @stats_hash ||= SynchronizedHash.new
+        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