newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/lib/new_relic/agent/method_tracer.rb

@@ -48,7 +48,7 @@ module NewRelic
         clazz.extend ClassMethods
         clazz.extend InstanceMethods
       end
-      
+
       # Defines modules used at instrumentation runtime, to do the
       # actual tracing of time spent
       module InstanceMethods
@@ -93,27 +93,29 @@ module NewRelic
         end
 
         alias trace_method_execution_no_scope trace_execution_unscoped #:nodoc:
-        
+
         # Refactored out of the previous trace_execution_scoped
         # method, most methods in this module relate to code used in
         # the #trace_execution_scoped method in this module
         module TraceExecutionScoped
+          extend self
+
           # Shorthand to return the NewRelic::Agent.instance
           def agent_instance
             NewRelic::Agent.instance
           end
-          
+
           # Shorthand to return the status of tracing
           def traced?
             NewRelic::Agent.is_execution_traced?
           end
-          
+
           # Tracing is disabled if we are not in a traced context and
           # no force option is supplied
           def trace_disabled?(options)
             !(traced? || options[:force])
           end
-          
+
           # Shorthand to return the current statistics engine
           def stat_engine
             agent_instance.stats_engine
@@ -128,24 +130,13 @@ module NewRelic
             stat_engine.get_stats_no_scope(name)
           end
 
-          def get_metric_specs(first_name, other_names, scope, options)
-            specs = other_names.map { |name| NewRelic::MetricSpec.new(name) }
-            if options[:metric]
-              if scope && scope != first_name
-                specs << NewRelic::MetricSpec.new(first_name, scope)
-              end
-              specs << NewRelic::MetricSpec.new(first_name) unless options[:scoped_metric_only]
-            end
-            specs
-          end
-          
           # Helper for setting a hash key if the hash key is nil,
           # instead of the default ||= behavior which sets if it is
           # false as well
           def set_if_nil(hash, key)
             hash[key] = true if hash[key].nil?
           end
-          
+
           # delegates to #agent_instance to push a trace execution
           # flag, only if execution of this metric is forced.
           #
@@ -154,7 +145,7 @@ module NewRelic
           def push_flag!(forced)
             agent_instance.push_trace_execution_flag(true) if forced
           end
-          
+
           # delegates to #agent_instance to pop the trace execution
           # flag, only if execution of this metric is
           # forced. otherwise this is taken care of for us
@@ -165,15 +156,15 @@ module NewRelic
           def pop_flag!(forced)
             agent_instance.pop_trace_execution_flag if forced
           end
-          
+
           # helper for logging errors to the newrelic_agent.log
           # properly. Logs the error at error level
-          def log_errors(code_area, metric)
+          def log_errors(code_area)
             yield
           rescue => e
-            ::NewRelic::Agent.logger.error("Caught exception in #{code_area}. Metric name = #{metric}", e)
+            ::NewRelic::Agent.logger.error("Caught exception in #{code_area}.", e)
           end
-          
+
           # provides the header for our traced execution scoped
           # method - gets the initial time, sets the tracing flag if
           # needed, and pushes the scope onto the metric stack
@@ -181,16 +172,66 @@ module NewRelic
           # the scope so that we can check for it later, to maintain
           # sanity. If the scope stack becomes unbalanced, this
           # transaction loses meaning.
-          def trace_execution_scoped_header(metric, options, t0=Time.now.to_f)
-            scope = log_errors("trace_execution_scoped header", metric) do
+          def trace_execution_scoped_header(options, t0=Time.now.to_f)
+            scope = log_errors("trace_execution_scoped header") do
               push_flag!(options[:force])
-              scope = stat_engine.push_scope(metric, t0, options[:deduct_call_time_from_parent])
+              scope = stat_engine.push_scope(:method_tracer, t0, options[:deduct_call_time_from_parent])
             end
             # needed in case we have an error, above, to always return
             # the start time.
             [t0, scope]
           end
-          
+
+          def metrics_for_current_transaction(first_name, other_names, options)
+            metrics = []
+
+            if !options[:scoped_metric_only]
+              metrics += other_names.map { |n| NewRelic::MetricSpec.new(n) }
+            end
+
+            if options[:metric]
+              if !options[:scoped_metric_only]
+                metrics << NewRelic::MetricSpec.new(first_name)
+              end
+              if in_transaction? && !options[:transaction]
+                metrics << NewRelic::MetricSpec.new(first_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)
+              end
+            end
+
+            metrics
+          end
+
+          def in_transaction?
+            NewRelic::Agent::Transaction.in_transaction?
+          end
+
+          def has_parent?
+            NewRelic::Agent::Transaction.current &&
+              NewRelic::Agent::Transaction.current.has_parent?
+          end
+
+          def metrics_for_parent_transaction(first_name, options)
+            if has_parent? && options[:metric] && options[:transaction]
+              [NewRelic::MetricSpec.new(first_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)]
+            else
+              []
+            end
+          end
+
+          def record_metrics(first_name, other_names, duration, exclusive, options)
+            metrics = metrics_for_current_transaction(first_name, other_names, options)
+            stat_engine.record_metrics(metrics) do |stat|
+              stat.record_data_point(duration, exclusive)
+            end
+
+            parent_metrics = metrics_for_parent_transaction(first_name, options)
+            parent_metrics.each do |metric|
+              stat_engine.transaction_stats_stack[-2].record(metric) do |stats|
+                stats.record_data_point(duration, exclusive)
+              end
+            end
+          end
+
           # Handles the end of the #trace_execution_scoped method -
           # calculating the time taken, popping the tracing flag if
           # needed, deducting time taken by children, and tracing the
@@ -199,17 +240,14 @@ module NewRelic
           # this method fails safely if the header does not manage to
           # push the scope onto the stack - it simply does not trace
           # any metrics.
-          def trace_execution_scoped_footer(t0, first_name, metric_specs, expected_scope, forced, t1=Time.now.to_f)
-            log_errors("trace_method_execution footer", first_name) do
-              duration = t1 - t0
-
-              pop_flag!(forced)
+          def trace_execution_scoped_footer(t0, first_name, metric_names, expected_scope, scope, options, t1=Time.now.to_f)
+            log_errors("trace_method_execution footer") do
+              pop_flag!(options[:force])
               if expected_scope
-                scope = stat_engine.pop_scope(expected_scope, duration, t1)
+                scope = stat_engine.pop_scope(expected_scope, first_name, t1)
+                duration = t1 - t0
                 exclusive = duration - scope.children_time
-                stat_engine.record_metrics(metric_specs) do |stat|
-                  stat.record_data_point(duration, exclusive)
-                end
+                record_metrics(first_name, metric_names, duration, exclusive, options)
               end
             end
           end
@@ -230,12 +268,11 @@ module NewRelic
             metric_names = Array(metric_names)
             first_name = metric_names.shift
             scope = stat_engine.scope_name
-            start_time, expected_scope = trace_execution_scoped_header(first_name, options)
-            begin 
+            start_time, expected_scope = trace_execution_scoped_header(options)
+            begin
               yield
             ensure
-              metric_specs = get_metric_specs(first_name, metric_names, scope, options)
-              trace_execution_scoped_footer(start_time, first_name, metric_specs, expected_scope, options[:force])
+              trace_execution_scoped_footer(start_time, first_name, metric_names, expected_scope, scope, options)
             end
           end
 
@@ -243,20 +280,20 @@ module NewRelic
         include TraceExecutionScoped
 
       end
-      
+
       # Defines methods used at the class level, for adding instrumentation
       module ClassMethods
         # contains methods refactored out of the #add_method_tracer method
         module AddMethodTracer
           ALLOWED_KEYS = [:force, :metric, :push_scope, :deduct_call_time_from_parent, :code_header, :code_footer, :scoped_metric_only].freeze
-          
+
           # used to verify that the keys passed to
           # NewRelic::Agent::MethodTracer::ClassMethods#add_method_tracer
           # are valid. Returns a list of keys that were unexpected
           def unrecognized_keys(expected, given)
             given.keys - expected
           end
-          
+
           # used to verify that the keys passed to
           # NewRelic::Agent::MethodTracer::ClassMethods#add_method_tracer
           # are valid. checks the expected list against the list
@@ -264,7 +301,7 @@ module NewRelic
           def any_unrecognized_keys?(expected, given)
             unrecognized_keys(expected, given).any?
           end
-          
+
           # raises an error when the
           # NewRelic::Agent::MethodTracer::ClassMethods#add_method_tracer
           # method is called with improper keys. This aids in
@@ -274,7 +311,7 @@ module NewRelic
               raise "Unrecognized options in add_method_tracer_call: #{unrecognized_keys(ALLOWED_KEYS, options).join(', ')}"
             end
           end
-          
+
           # Sets the options for deducting call time from
           # parents. This defaults to true if we are recording a metric, but
           # can be overridden by the user if desired.
@@ -284,7 +321,7 @@ module NewRelic
           def set_deduct_call_time_based_on_metric(options)
             {:deduct_call_time_from_parent => !!options[:metric]}.merge(options)
           end
-          
+
           # validity checking - add_method_tracer must receive either
           # push scope or metric, or else it would record no
           # data. Raises an error if this is the case
@@ -295,7 +332,7 @@ module NewRelic
           end
 
           DEFAULT_SETTINGS = {:push_scope => true, :metric => true, :force => false, :code_header => "", :code_footer => "", :scoped_metric_only => false}.freeze
-          
+
           # Checks the provided options to make sure that they make
           # sense. Raises an error if the options are incorrect to
           # assist with debugging, so that errors occur at class
@@ -315,7 +352,7 @@ module NewRelic
           def default_metric_name_code(method_name)
             "Custom/#{self.name}/#{method_name.to_s}"
           end
-          
+
           # Checks to see if the method we are attempting to trace
           # actually exists or not. #add_method_tracer can't do
           # anything if the method doesn't exist.
@@ -324,7 +361,7 @@ module NewRelic
             ::NewRelic::Agent.logger.error("Did not trace #{self.name}##{method_name} because that method does not exist") unless exists
             exists
           end
-          
+
           # Checks to see if we have already traced a method with a
           # given metric by checking to see if the traced method
           # exists. Warns the user if methods are being double-traced
@@ -334,7 +371,7 @@ module NewRelic
             ::NewRelic::Agent.logger.error("Attempt to trace a method twice with the same metric: Method = #{method_name}, Metric Name = #{metric_name_code}") if exists
             exists
           end
-          
+
           # Returns a code snippet to be eval'd that skips tracing
           # when the agent is not tracing execution. turns
           # instrumentation into effectively one method call overhead
@@ -344,7 +381,7 @@ module NewRelic
               "return #{_untraced_method_name(method_name, metric_name_code)}(*args, &block) unless NewRelic::Agent.is_execution_traced?\n"
             end.to_s + options[:code_header].to_s
           end
-          
+
           # returns an eval-able string that contains the traced
           # method code used if the agent is not creating a scope for
           # use in scoped metrics.
@@ -382,7 +419,7 @@ module NewRelic
               result
             end"
           end
-          
+
           # Decides which code snippet we should be eval'ing in this
           # context, based on the options.
           def code_to_eval(method_name, metric_name_code, options)
@@ -397,7 +434,7 @@ module NewRelic
         include AddMethodTracer
 
 
-        
+
         # Add a method tracer to the specified method.
         #
         # === Common Options
@@ -500,22 +537,22 @@ module NewRelic
           end
         end
         private
-        
+
         # given a method and a metric, this method returns the
         # untraced alias of the method name
         def _untraced_method_name(method_name, metric_name)
           "#{_sanitize_name(method_name)}_without_trace_#{_sanitize_name(metric_name)}"
         end
-        
+
         # given a method and a metric, this method returns the traced
         # alias of the method name
         def _traced_method_name(method_name, metric_name)
           "#{_sanitize_name(method_name)}_with_trace_#{_sanitize_name(metric_name)}"
         end
-        
+
         # makes sure that method names do not contain characters that
         # might break the interpreter, for example ! or ? characters
-        # that are not allowed in the middle of method names 
+        # that are not allowed in the middle of method names
         def _sanitize_name(name)
           name.to_s.tr_s('^a-zA-Z0-9', '_')
         end

data/lib/new_relic/agent/null_logger.rb

@@ -7,6 +7,12 @@
 module NewRelic
   module Agent
     class NullLogger
+      def fatal(*args); end
+      def error(*args); end
+      def warn(*args);  end
+      def info(*args);  end
+      def debug(*args); end
+
       def method_missing(method, *args, &blk)
         nil
       end

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

@@ -11,6 +11,11 @@ module NewRelic
         attr_reader :last_time
         def initialize
           super :cpu
+          @processor_count = NewRelic::Agent::SystemInfo.processor_count
+          if @processor_count.nil?
+            NewRelic::Agent.logger.warn("Failed to determine processor count, assuming 1")
+            @processor_count = 1
+          end
           poll
         end
 
@@ -42,7 +47,7 @@ module NewRelic
           if @last_time
             elapsed = now - @last_time
             return if elapsed < 1 # Causing some kind of math underflow
-            num_processors = NewRelic::Control.instance.local_env.processors || 1
+
             usertime = t.utime - @last_utime
             systemtime = t.stime - @last_stime
 
@@ -50,10 +55,10 @@ module NewRelic
             record_usertime(usertime) if usertime >= 0
 
             # Calculate the true utilization by taking cpu times and dividing by
-            # elapsed time X num_processors.
+            # elapsed time X processor_count.
 
-            record_user_util(usertime / (elapsed * num_processors))
-            record_system_util(systemtime / (elapsed * num_processors))
+            record_user_util(usertime / (elapsed * @processor_count))
+            record_system_util(systemtime / (elapsed * @processor_count))
           end
           @last_utime = t.utime
           @last_stime = t.stime

data/lib/new_relic/agent/sql_sampler.rb

@@ -30,7 +30,7 @@ module NewRelic
         @sql_traces = {}
         clear_transaction_data
 
-        # This lock is used to synchronize access to the @last_sample
+        # This lock is used to synchronize access to @sql_traces
         # and related variables. It can become necessary on JRuby or
         # any 'honest-to-god'-multithreaded system
         @samples_lock = Mutex.new
@@ -43,12 +43,12 @@ module NewRelic
           Agent.config[:'transaction_tracer.enabled']
       end
 
-      def notice_transaction(path, uri=nil, params={})
+      def notice_transaction(uri=nil, params={})
         if NewRelic::Agent.instance.transaction_sampler.builder
           guid = NewRelic::Agent.instance.transaction_sampler.builder.sample.guid
         end
         if Agent.config[:'slow_sql.enabled'] && transaction_data
-          transaction_data.set_transaction_info(path, uri, params, guid)
+          transaction_data.set_transaction_info(uri, params, guid)
         end
       end
 
@@ -69,8 +69,9 @@ module NewRelic
       end
 
       # This is called when we are done with the transaction.
-      def notice_scope_empty(time=Time.now)
+      def notice_scope_empty(name, time=Time.now)
         data = transaction_data
+        data.set_transaction_name(name)
         clear_transaction_data
 
         if data.sql_data.size > 0
@@ -145,12 +146,15 @@ module NewRelic
         @sql_data = []
       end
 
-      def set_transaction_info(path, uri, params, guid)
-        @path = path
+      def set_transaction_info(uri, params, guid)
         @uri = uri
         @params = params
         @guid = guid
       end
+
+      def set_transaction_name(name)
+        @path = name
+      end
     end
 
     class SlowSql

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

@@ -9,6 +9,8 @@ module NewRelic
     class StatsEngine
       # Handles methods related to actual Metric collection
       module MetricStats
+        SCOPE_PLACEHOLDER = :__SCOPE__
+
         # Lookup and write to the named metric in a single call.
         #
         # This method is thead-safe, and is preferred to the lookup / modify
@@ -16,13 +18,19 @@ module NewRelic
         def record_metrics(metric_names_or_specs, value=nil, options={}, &blk)
           defaults = {
             :scoped => false,
-            :scope => scope_name
+            :scope => in_transaction? ? SCOPE_PLACEHOLDER : nil
           }
           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)
+
+          if in_transaction?
+            transaction_stats_hash.record(specs, value, &blk)
+          else
+            with_stats_lock do
+              @stats_hash.record(specs, value, &blk)
+            end
           end
         end
 
@@ -155,6 +163,14 @@ module NewRelic
             @stats_hash.keys.map { |spec| spec.to_s }
           end
         end
+
+        def metric_specs
+          with_stats_lock { @stats_hash.keys }
+        end
+
+        def in_transaction?
+          !!transaction_stats_hash
+        end
       end
     end
   end

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

@@ -2,17 +2,17 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-# -*- 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 :deduct_call_time_from_parent
-      attr_accessor :name, :children_time
-      def initialize(name, deduct_call_time)
-        @name = name
+      attr_reader :deduct_call_time_from_parent, :tag
+      attr_accessor :name, :start_time, :children_time
+      def initialize(tag, start_time, deduct_call_time)
+        @tag = tag
+        @start_time = start_time
         @deduct_call_time_from_parent = deduct_call_time
         @children_time = 0
       end
@@ -50,29 +50,38 @@ module Agent
 
       # 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)
+      # The generated segment will not be named until the corresponding
+      # pop_scope call is made.
+      # +tag+ should be a Symbol, and is only used for debugging purposes to
+      # 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 metric, time if sampler_enabled?
-        scope = ScopeStackElement.new(metric, deduct_call_time_from_parent)
+        @transaction_sampler.notice_push_scope(time) if sampler_enabled?
+        scope = ScopeStackElement.new(tag, time, 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)
+      # +expected_scope+ should be the ScopeStackElement that was returned by
+      # the corresponding push_scope call.
+      # +name+ is the name that will be applied to the generated transaction
+      # trace segment.
+      def pop_scope(expected_scope, name, time=Time.now.to_f)
         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
+        fail "unbalanced pop from blame stack, got #{scope ? scope.tag : 'nil'}, expected #{expected_scope ? expected_scope.tag : 'nil'}" if scope != expected_scope
 
         if !stack.empty?
           if scope.deduct_call_time_from_parent
-            stack.last.children_time += duration
+            stack.last.children_time += (time - scope.start_time)
           else
             stack.last.children_time += scope.children_time
           end
         end
-        @transaction_sampler.notice_pop_scope(scope.name, time) if sampler_enabled?
+        @transaction_sampler.notice_pop_scope(name, time) if sampler_enabled?
+        scope.name = name
         scope
       end
 
@@ -80,17 +89,6 @@ module Agent
         @transaction_sampler && Agent.config[:'transaction_tracer.enabled']
       end
 
-      # Rename the segment associated with the last pushed scope to +new_name+.
-      def rename_scope_segment( new_name )
-        self.peek_scope.name = new_name
-        @transaction_sampler.rename_scope_segment( new_name ) if sampler_enabled?
-      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.
@@ -109,11 +107,8 @@ module Agent
       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
-        NewRelic::Agent.instance.events.notify(:start_transaction, name)
-        GCProfiler.init
+      def start_transaction
+        NewRelic::Agent.instance.events.notify(:start_transaction)
       end
 
       # Try to clean up gracefully, otherwise we leave things hanging around on thread locals.
@@ -121,11 +116,6 @@ module Agent
       # and is ignored.
       #
       def end_transaction
-        elapsed = GCProfiler.capture
-        if @transaction_sampler && @transaction_sampler.last_sample
-          @transaction_sampler.last_sample.params[:custom_params] ||= {}
-          @transaction_sampler.last_sample.params[:custom_params][:gc_time] = elapsed
-        end
         stack = scope_stack
 
         if stack && stack.empty?
@@ -134,12 +124,41 @@ module Agent
         end
       end
 
-      private
+      def transaction_stats_hash
+        transaction_stats_stack.last
+      end
+
+      def push_transaction_stats
+        transaction_stats_stack << StatsHash.new
+      end
+
+      def pop_transaction_stats(transaction_name)
+        Thread::current[:newrelic_scope_stack] ||= []
+        stats = transaction_stats_stack.pop
+        merge!(apply_scopes(stats, transaction_name)) if stats
+        stats
+      end
+
+      def apply_scopes(stats_hash, resolved_name)
+        new_stats = StatsHash.new
+        stats_hash.each do |spec, stats|
+          if spec.scope != '' &&
+              spec.scope.to_sym == StatsEngine::SCOPE_PLACEHOLDER
+            spec.scope = resolved_name
+          end
+          new_stats[spec] = stats
+        end
+        return new_stats
+      end
 
       # Returns the current scope stack, memoized to a thread local variable
       def scope_stack
         Thread::current[:newrelic_scope_stack] ||= []
       end
+
+      def transaction_stats_stack
+        Thread.current[:newrelic_transaction_stack] ||= []
+      end
     end
   end
 end