newrelic_rpm 3.0.1 → 3.1.0.beta1

data/lib/new_relic/agent/instrumentation/metric_frame.rb

@@ -1,3 +1,5 @@
+require 'new_relic/agent/instrumentation/metric_frame/pop'
+
 # A struct holding the information required to measure a controller
 # action.  This is put on the thread local.  Handles the issue of
 # re-entrancy, or nested action calls.
@@ -8,6 +10,9 @@ module NewRelic
   module Agent
     module Instrumentation
       class MetricFrame
+        # helper module refactored out of the `pop` method
+        include Pop
+
         attr_accessor :start       # A Time instance for the start time, never nil
         attr_accessor :apdex_start # A Time instance used for calculating the apdex score, which
         # might end up being @start, or it might be further upstream if
@@ -35,7 +40,7 @@ module NewRelic
           # Reconnect to the server if necessary.  This is only done
           # for old versions of passenger that don't implement an explicit after_fork
           # event.
-          NewRelic::Agent.instance.after_fork(:keep_retrying => false) if @@check_server_connection
+          agent.after_fork(:keep_retrying => false) if @@check_server_connection
 
           Thread.current[:newrelic_metric_frame] = new
         end
@@ -50,6 +55,10 @@ module NewRelic
           current && current.referer
         end
 
+        def self.agent
+          NewRelic::Agent.instance
+        end
+
         @@java_classes_loaded = false
 
         if defined? JRuby
@@ -71,10 +80,22 @@ module NewRelic
           @process_cpu_start = process_cpu
         end
 
+        def agent
+          NewRelic::Agent.instance
+        end
+
+        def transaction_sampler
+          agent.transaction_sampler
+        end
+
+        private :agent
+        private :transaction_sampler
+
+
         # Indicate that we are entering a measured controller action or task.
         # Make sure you unwind every push with a pop call.
         def push(m)
-          NewRelic::Agent.instance.transaction_sampler.notice_first_scope_push(start)
+          transaction_sampler.notice_first_scope_push(start)
           @path_stack.push NewRelic::MetricParser::MetricParser.for_metric_named(m)
         end
 
@@ -96,15 +117,16 @@ module NewRelic
 
         # Call this to ensure that the current transaction is not saved
         def abort_transaction!
-          NewRelic::Agent.instance.transaction_sampler.ignore_transaction
+          transaction_sampler.ignore_transaction
         end
-        # This needs to be called after entering the call to trace the controller action, otherwise
-        # the controller action blames itself.  It gets reset in the normal #pop call.
+        # This needs to be called after entering the call to trace the
+        # controller action, otherwise the controller action blames
+        # itself.  It gets reset in the normal #pop call.
         def start_transaction
-          NewRelic::Agent.instance.stats_engine.start_transaction metric_name
+          agent.stats_engine.start_transaction metric_name
           # Only push the transaction context info once, on entry:
           if @path_stack.size == 1
-            NewRelic::Agent.instance.transaction_sampler.notice_transaction(metric_name, uri, filtered_params)
+            transaction_sampler.notice_transaction(metric_name, uri, filtered_params)
           end
         end
 
@@ -121,28 +143,11 @@ module NewRelic
         # does the appropriate wrapup of the context.
         def pop
           metric = @path_stack.pop
-          if metric.nil?
-            NewRelic::Agent.logger.error "Underflow in metric frames: #{caller.join("\n   ")}"
-          end
+          log_underflow if metric.nil?
           if @path_stack.empty?
-            if NewRelic::Agent.is_execution_traced?
-              cpu_burn = nil
-              if @process_cpu_start
-                cpu_burn = process_cpu - @process_cpu_start
-              elsif @jruby_cpu_start
-                cpu_burn = jruby_cpu_time - @jruby_cpu_start
-                NewRelic::Agent.get_stats_no_scope(NewRelic::Metrics::USER_TIME).record_data_point(cpu_burn)
-              end
-              NewRelic::Agent.instance.transaction_sampler.notice_transaction_cpu_time(cpu_burn) if cpu_burn
-              NewRelic::Agent.instance.histogram.process((Time.now - start).to_f) if metric.is_web_transaction?
-              NewRelic::Agent.instance.transaction_sampler.notice_scope_empty
-            end
-            NewRelic::Agent.instance.stats_engine.end_transaction
-            Thread.current[:newrelic_start_time] = (Thread.current[:newrelic_metric_frame].start rescue nil)
-            Thread.current[:newrelic_metric_frame] = nil
-          else # path stack not empty
-            # change the transaction name back to whatever was on the stack.
-            NewRelic::Agent.instance.stats_engine.scope_name = metric_name
+            handle_empty_path_stack(metric)
+          else
+            set_new_scope!(current_stack_metric)
           end
         end
 
@@ -157,14 +162,15 @@ module NewRelic
         # Anything left over is treated as custom params
 
         def self.notice_error(e, options={})
-          if request = options.delete(:request)
+          request = options.delete(:request)
+          if request
             options[:referer] = referer_from_request(request)
             options[:uri] = uri_from_request(request)
           end
           if current
             current.notice_error(e, options)
           else
-            NewRelic::Agent.instance.error_collector.notice_error(e, options)
+            agent.error_collector.notice_error(e, options)
           end
         end
 
@@ -177,7 +183,7 @@ module NewRelic
           options[:metric] = metric_name
           options.merge!(custom_parameters)
           if exception != e
-            result = NewRelic::Agent.instance.error_collector.notice_error(e, options)
+            result = agent.error_collector.notice_error(e, options)
             self.exception = result if result
           end
         end
@@ -242,7 +248,8 @@ module NewRelic
         end
 
         def self.recording_web_transaction?
-          if c = Thread.current[:newrelic_metric_frame]
+          c = Thread.current[:newrelic_metric_frame]
+          if c
             c.recording_web_transaction?
           end
         end
@@ -276,8 +283,8 @@ module NewRelic
         end
 
         def self.record_apdex(current_metric, action_duration, total_duration, is_error)
-          summary_stat = NewRelic::Agent.instance.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)
-          controller_stat = NewRelic::Agent.instance.stats_engine.get_custom_stats(current_metric.apdex_metric_path, NewRelic::ApdexStats)
+          summary_stat = agent.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)
+          controller_stat = agent.stats_engine.get_custom_stats(current_metric.apdex_metric_path, NewRelic::ApdexStats)
           update_apdex(summary_stat, total_duration, is_error)
           update_apdex(controller_stat, action_duration, is_error)
         end
@@ -313,7 +320,6 @@ module NewRelic
           java_utime = threadMBean.getCurrentThreadUserTime()  # ns
           -1 == java_utime ? 0.0 : java_utime/1e9
         end
-
       end
     end
   end

data/lib/new_relic/agent/instrumentation/metric_frame/pop.rb

@@ -0,0 +1,92 @@
+require 'new_relic/agent/instrumentation'
+module NewRelic
+  module Agent
+    module Instrumentation
+      class MetricFrame
+        module Pop
+
+          def clear_thread_metric_frame!
+            Thread.current[:newrelic_metric_frame] = nil
+          end
+
+          def set_last_start_time!
+            frame = Thread.current[:newrelic_metric_frame]
+            if frame && frame.respond_to?(:start)
+              Thread.current[:newrelic_start_time] = Thread.current[:newrelic_metric_frame].start
+            end
+          end
+
+          def set_new_scope!(metric)
+            agent.stats_engine.scope_name = metric
+          end
+
+          def log_underflow
+            NewRelic::Agent.logger.error "Underflow in metric frames: #{caller.join("\n   ")}"
+          end
+
+          def process_histogram_for_transaction(ending)
+            agent.histogram.process((ending - start).to_f)
+          end
+
+          def notice_scope_empty
+            transaction_sampler.notice_scope_empty
+          end
+
+          def record_transaction_cpu
+            burn = cpu_burn
+            transaction_sampler.notice_transaction_cpu_time(burn) if burn
+          end
+
+          def normal_cpu_burn
+            return unless @process_cpu_start
+            process_cpu - @process_cpu_start
+          end
+
+          def jruby_cpu_burn
+            return unless @jruby_cpu_start
+            burn = (jruby_cpu_time - @jruby_cpu_start)
+            record_jruby_cpu_burn(burn)
+            burn
+          end
+
+          # we need to do this here because the normal cpu sampler
+          # process doesn't work on JRuby. See the cpu_sampler.rb file
+          # to understand where cpu is recorded for non-jruby processes
+          def record_jruby_cpu_burn(burn)
+            NewRelic::Agent.get_stats_no_scope(NewRelic::Metrics::USER_TIME).record_data_point(burn)
+          end
+
+          def cpu_burn
+            normal_cpu_burn || jruby_cpu_burn
+          end
+
+          def end_transaction!
+            agent.stats_engine.end_transaction
+          end
+
+          def notify_transaction_sampler(web_transaction)
+            record_transaction_cpu
+            process_histogram_for_transaction(Time.now) if web_transaction
+            notice_scope_empty
+          end
+
+          def traced?
+            NewRelic::Agent.is_execution_traced?
+          end
+
+          def handle_empty_path_stack(metric)
+            raise 'path stack not empty' unless @path_stack.empty?
+            notify_transaction_sampler(metric.is_web_transaction?) if traced?
+            end_transaction!
+            set_last_start_time!
+            clear_thread_metric_frame!
+          end
+
+          def current_stack_metric
+            metric_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/method_tracer.rb

@@ -81,8 +81,6 @@ module NewRelic
           end
         end
 
-        EMPTY_ARRAY = [].freeze
-
         # Deprecated. Use #trace_execution_scoped, a version with an options hash.
         def trace_method_execution_with_scope(metric_names, produce_metric, deduct_call_time_from_parent, scoped_metric_only=false, &block) #:nodoc:
           trace_execution_scoped(metric_names,

data/lib/new_relic/agent/shim_agent.rb

@@ -18,6 +18,8 @@ module NewRelic
       def after_fork *args; end
       def start *args; end
       def shutdown; end
+      def serialize; end
+      def merge_data_from(*args); end
       def push_trace_execution_flag(*args); end
       def pop_trace_execution_flag(*args); end
       def browser_timing_header; "" end

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

@@ -39,98 +39,127 @@ module NewRelic
           end
         end
 
-        # The stats hash hashes either a metric name for an unscoped metric,
-        # or a metric_spec for a scoped metric value.
-        def lookup_stat(metric_name)
-          stats_hash[metric_name]
-        end
-
         def metrics
           stats_hash.keys.map(&:to_s)
         end
 
         def get_stats_no_scope(metric_name)
-          stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new
+          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[metric_name] ||= stat_class.new
+          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
+          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::MethodTraceStats.new
-            else
-              stats = stats_hash[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
+              stats = stats_hash[spec] ||= NewRelic::ScopedMethodTraceStats.new(stats)
             end
-            stats
+          end
+          stats
         end
 
-        def lookup_stats(metric_name, scope_name = nil)
-            stats_hash[NewRelic::MetricSpec.new(metric_name, scope_name)] ||
-            stats_hash[metric_name]
+        def lookup_stats(metric_name, scope_name = '')
+          stats_hash[NewRelic::MetricSpec.new(metric_name, scope_name)]
         end
-        # 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)
-            timeslice_data = {}
-            poll harvest_samplers
-            stats_hash.keys.each do | metric_spec |
 
+        module Harvest
 
-              # get a copy of the stats collected since the last harvest, and clear
-              # the stats inside our hash table for the next time slice.
-              stats = stats_hash[metric_spec]
-
-              # we have an optimization for unscoped metrics
-              if !(metric_spec.is_a? NewRelic::MetricSpec)
-                metric_spec = NewRelic::MetricSpec.new metric_spec
+          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
 
-              if stats.nil?
-                raise "Nil stats for #{metric_spec.name} (#{metric_spec.scope})"
-              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
 
-              stats_copy = stats.clone
-              stats.reset
+          def clone_and_reset_stats(metric_spec, stats)
+            if stats.nil?
+              raise "Nil stats for #{metric_spec.name} (#{metric_spec.scope})"
+            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
-              previous_metric_data = previous_timeslice_data[metric_spec]
-              stats_copy.merge! previous_metric_data.stats unless previous_metric_data.nil?
+            stats_copy = stats.clone
+            stats.reset
+            stats_copy
+          end
 
-              # don't bother collecting and reporting stats that have zero-values for this timeslice.
-              # significant performance boost and storage savings.
-              unless stats_copy.is_reset?
+          # 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
 
-                id = metric_ids[metric_spec]
-                metric_spec_for_transport = id ? nil : metric_spec
+          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
 
-                metric_data = NewRelic::MetricData.new(metric_spec_for_transport, stats_copy, id)
+          def merge_stats(other_engine_or_hash, metric_ids)
+            old_data = get_stats_hash_from(other_engine_or_hash)
 
-                timeslice_data[metric_spec] = metric_data
-              end
-            end
+            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.