newrelic_rpm 3.8.0.218 → 3.8.1.221

data/lib/new_relic/agent/datastores/mongo.rb

@@ -10,13 +10,7 @@ module NewRelic
           # No version constant in < 2.0 versions of Mongo :(
           defined?(::Mongo) &&
             defined?(::Mongo::MongoClient) &&
-            !is_version2? &&
-            !is_version_1_10_or_later?
-        end
-
-        def self.is_version_1_10_or_later?
-          # Again, no VERSION constant in 1.x, so we have to rely on constant checks
-          defined?(::Mongo::CollectionOperationWriter)
+            !is_version2?
         end
 
         # At present we explicitly don't support version 2.x of the driver yet
@@ -24,6 +18,11 @@ module NewRelic
           defined?(::Mongo::VERSION) &&
             NewRelic::VersionNumber.new(::Mongo::VERSION) > NewRelic::VersionNumber.new("2.0.0")
         end
+
+        def self.is_version_1_10_or_later?
+          # Again, no VERSION constant in 1.x, so we have to rely on constant checks
+          defined?(::Mongo::CollectionOperationWriter)
+        end
       end
     end
   end

data/lib/new_relic/agent/datastores/mongo/metric_translator.rb

@@ -12,21 +12,27 @@ module NewRelic
           def self.metrics_for(name, payload, request_type = :web)
             payload ||= {}
 
-            database = payload[:database]
-            collection = payload[:collection]
-
-            if collection_in_selector?(collection, payload)
+            if collection_in_selector?(payload)
               command_key = command_key_from_selector(payload)
               name        = get_name_from_selector(command_key, payload)
               collection  = get_collection_from_selector(command_key, payload)
+            else
+              collection = payload[:collection]
             end
 
+            # The 1.10.0 version of the mongo driver renamed 'remove' to
+            # 'delete', but for metric consistency with previous versions we
+            # want to keep it as 'remove'.
+            name = 'remove' if name.to_s == 'delete'
+
             if self.find_one?(name, payload)
               name = 'findOne'
             elsif self.find_and_remove?(name, payload)
               name = 'findAndRemove'
             elsif self.find_and_modify?(name, payload)
               name = 'findAndModify'
+            elsif self.create_indexes?(name, payload)
+              name = 'createIndexes'
             elsif self.create_index?(name, payload)
               name = 'createIndex'
               collection = self.collection_name_from_index(payload)
@@ -44,9 +50,7 @@ module NewRelic
               collection = collection_name_from_rename_selector(payload)
             end
 
-            metrics = build_metrics(name, collection, request_type)
-
-            metrics
+            build_metrics(name, collection, request_type)
           end
 
           def self.build_metrics(name, collection, request_type = :web)
@@ -70,8 +74,8 @@ module NewRelic
             "Datastore/instance/MongoDB/#{host}:#{port}/#{database}"
           end
 
-          def self.collection_in_selector?(collection, payload)
-            collection == '$cmd' && payload[:selector]
+          def self.collection_in_selector?(payload)
+            payload[:collection] == '$cmd' && payload[:selector]
           end
 
           NAMES_IN_SELECTOR = [
@@ -84,6 +88,7 @@ module NewRelic
 
             :distinct,
 
+            :createIndexes,
             :deleteIndexes,
             :reIndex,
 
@@ -131,6 +136,10 @@ module NewRelic
             name == :findandmodify && payload[:selector] && payload[:selector][:remove]
           end
 
+          def self.create_indexes?(name, paylod)
+            name == :createIndexes
+          end
+
           def self.create_index?(name, payload)
             name == :insert && payload[:collection] == "system.indexes"
           end
@@ -156,11 +165,21 @@ module NewRelic
           end
 
           def self.collection_name_from_index(payload)
-            if payload[:documents] && payload[:documents].first[:ns]
-              payload[:documents].first[:ns].split('.').last
-            else
-              'system.indexes'
+            if payload[:documents]
+              if payload[:documents].is_a?(Array)
+                # mongo gem versions pre 1.10.0
+                document = payload[:documents].first
+              else
+                # mongo gem versions 1.10.0 and later
+                document = payload[:documents]
+              end
+
+              if document && document[:ns]
+                return document[:ns].split('.').last
+              end
             end
+
+            'system.indexes'
           end
 
           def self.collection_name_from_group_selector(payload)

data/lib/new_relic/agent/datastores/mongo/statement_formatter.rb

@@ -24,16 +24,17 @@ module NewRelic
             :selector
           ]
 
-          def self.format(statement)
+          def self.format(statement, operation)
             return nil unless NewRelic::Agent.config[:'mongo.capture_queries']
 
-            result = {}
+            result = { :operation => operation }
+
             PLAINTEXT_KEYS.each do |key|
               result[key] = statement[key] if statement.key?(key)
             end
 
             OBFUSCATE_KEYS.each do |key|
-              if statement.key?(key)
+              if statement.key?(key) && statement[key]
                 obfuscated = obfuscate(statement[key])
                 result[key] = obfuscated if obfuscated
               end

data/lib/new_relic/agent/error_collector.rb

@@ -110,7 +110,7 @@ module NewRelic
           if options[:metric] && options[:metric] != ::NewRelic::Agent::UNKNOWN_METRIC
             "Errors/#{options[:metric]}"
           else
-            if txn = TransactionState.get.transaction
+            if txn = TransactionState.get.most_recent_transaction
               "Errors/#{txn.name}"
             end
           end
@@ -265,7 +265,7 @@ module NewRelic
         return if should_exit_notice_error?(exception)
         increment_error_count!(exception, options)
         NewRelic::Agent.instance.events.notify(:notice_error, exception, options)
-        action_path     = fetch_from_options(options, :metric, "")
+        action_path       = fetch_from_options(options, :metric, "")
         exception_options = error_params_from_options(options).merge(exception_info(exception))
         add_to_error_queue(NewRelic::NoticedError.new(action_path, exception_options, exception))
         exception

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

@@ -42,14 +42,7 @@ module NewRelic
           event = pop_event(id)
           event.payload.merge!(payload)
 
-          set_enduser_ignore if event.enduser_ignored?
-
           if NewRelic::Agent.is_execution_traced? && !event.ignored?
-            event.finalize_metric_name!
-            record_queue_time(event)
-            record_metrics(event)
-            record_apdex(event)
-            record_instance_busy(event)
             stop_transaction(event)
           else
             Agent.instance.pop_trace_execution_flag
@@ -58,59 +51,19 @@ module NewRelic
           log_notification_error(e, name, 'finish')
         end
 
-        def set_enduser_ignore
-          TransactionState.get.request_ignore_enduser = true
-        end
-
-        def record_metrics(event)
-          controller_metric = MetricSpec.new(event.metric_name)
-          txn = Transaction.current
-          metrics = [ 'HttpDispatcher']
-          if txn.has_parent?
-            parent_metric = MetricSpec.new(event.metric_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)
-            record_metric_on_parent_transaction(parent_metric, event.duration)
-          end
-          metrics << controller_metric.dup
-
-          Agent.instance.stats_engine.record_metrics(metrics, event.duration)
-        end
-
-        def record_metric_on_parent_transaction(metric, time)
-          NewRelic::Agent::Transaction.parent.stats_hash.record(metric, time)
-        end
-
-        def record_apdex(event)
-          return if event.apdex_ignored?
-          Transaction.record_apdex(event.end, event.exception_encountered?)
-        end
-
-        def record_instance_busy(event)
-          BusyCalculator.dispatcher_start(event.time)
-          BusyCalculator.dispatcher_finish(event.end)
-        end
-
-        def record_queue_time(event)
-          return unless event.queue_start
-          return unless NewRelic::Agent::Transaction.current.root?
-          QueueTime.record_frontend_metrics(event.queue_start, event.time)
-        end
-
         def start_transaction(event)
-          txn = Transaction.start(:controller,
-                                  :request => event.request,
-                                  :filtered_params => filter(event.payload[:params]))
-          txn.apdex_start = (event.queue_start || event.time)
-          txn.name = event.metric_name
-
-          event.scope = Agent.instance.stats_engine \
-            .push_scope(:action_controller, event.time)
+          Transaction.start(:controller,
+                            :request          => event.request,
+                            :filtered_params  => filter(event.payload[:params]),
+                            :apdex_start_time => event.queue_start,
+                            :transaction_name => event.metric_name)
         end
 
         def stop_transaction(event)
-          Agent.instance.stats_engine \
-            .pop_scope(event.scope, event.metric_name, event.end)
-        ensure
-          Transaction.stop
+          Transaction.stop(Time.now,
+                           :exception_encountered => event.exception_encountered?,
+                           :ignore_apdex          => event.apdex_ignored?,
+                           :ignore_enduser        => event.enduser_ignored?)
         end
 
         def filter(params)
@@ -120,7 +73,7 @@ module NewRelic
       end
 
       class ControllerEvent < Event
-        attr_accessor :parent, :scope
+        attr_accessor :parent
         attr_reader :queue_start, :request
 
         def initialize(name, start, ending, transaction_id, payload, request)
@@ -140,18 +93,6 @@ module NewRelic
           @metric_name || "Controller/#{metric_path}/#{metric_action}"
         end
 
-        def finalize_metric_name!
-          txn = NewRelic::Agent::Transaction.current
-
-          # the event provides the default name but the transaction has the final say
-          txn.name ||= metric_name
-
-          # this applies the transaction name rules if not already applied
-          txn.freeze_name
-          @metric_name = txn.name
-          return @metric_name
-        end
-
         def metric_path
           @controller_class.controller_path
         end

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

@@ -14,8 +14,7 @@ module NewRelic
           push_event(event)
 
           if NewRelic::Agent.is_execution_traced? && event.recordable?
-            event.scope = NewRelic::Agent.instance.stats_engine \
-              .push_scope(:action_view, event.time)
+            event.frame = NewRelic::Agent::TracedMethodStack.push_frame(:action_view, event.time)
           end
         rescue => e
           log_notification_error(e, name, 'start')
@@ -25,16 +24,15 @@ module NewRelic
           event = pop_event(id)
 
           if NewRelic::Agent.is_execution_traced? && event.recordable?
-            scope = NewRelic::Agent.instance.stats_engine \
-              .pop_scope(event.scope, event.metric_name, event.end)
-            record_metrics(event, scope)
+            frame = NewRelic::Agent::TracedMethodStack.pop_frame(event.frame, event.metric_name, event.end)
+            record_metrics(event, frame)
           end
         rescue => e
           log_notification_error(e, name, 'finish')
         end
 
-        def record_metrics(event, scope)
-          exclusive = event.duration - scope.children_time
+        def record_metrics(event, frame)
+          exclusive = event.duration - frame.children_time
           metric_specs = [
             NewRelic::MetricSpec.new(event.metric_name),
             NewRelic::MetricSpec.new(event.metric_name, StatsEngine::MetricStats::SCOPE_PLACEHOLDER)

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

@@ -42,7 +42,7 @@ module NewRelic
           metric = base_metric(event)
 
           # enter transaction trace segment
-          scope = NewRelic::Agent.instance.stats_engine.push_scope(:active_record, event.time)
+          frame = NewRelic::Agent::TracedMethodStack.push_frame(:active_record, event.time)
 
           NewRelic::Agent.instance.transaction_sampler \
             .notice_sql(event.payload[:sql], config,
@@ -55,7 +55,7 @@ module NewRelic
                         &method(:get_explain_plan))
 
           # exit transaction trace segment
-          NewRelic::Agent.instance.stats_engine.pop_scope(scope, metric, event.end)
+          NewRelic::Agent::TracedMethodStack.pop_frame(frame, metric, event.end)
         end
 
         def record_metrics(event)

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

@@ -147,60 +147,67 @@ module NewRelic
           def add_transaction_tracer(method, options={})
             # The metric path:
             options[:name] ||= method.to_s
-            # create the argument list:
-            options_arg = []
-            options.each do |key, value|
-              valuestr = case
-                         when value.is_a?(Symbol)
-                           value.inspect
-                         when key == :params
-                           value.to_s
-                         else
-                           %Q["#{value.to_s}"]
-                         end
-              options_arg << %Q[:#{key} => #{valuestr}]
-            end
-            traced_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
-            visibility = NewRelic::Helper.instance_method_visibility self, method
 
-            without_method_name = "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}"
-            with_method_name = "#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}"
+            argument_list = generate_argument_list(options)
+            traced_method, punctuation = parse_punctuation(method)
+            with_method_name, without_method_name = build_method_names(traced_method, punctuation)
 
-            if NewRelic::Helper.instance_methods_include?(self, with_method_name)
+            if already_added_transaction_tracer?(self, with_method_name)
               ::NewRelic::Agent.logger.warn("Transaction tracer already in place for class = #{self.name}, method = #{method.to_s}, skipping")
               return
             end
 
             class_eval <<-EOC
-              def #{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}(*args, &block)
-                perform_action_with_newrelic_trace(#{options_arg.join(',')}) do
-                  #{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}(*args, &block)
+              def #{with_method_name}(*args, &block)
+                perform_action_with_newrelic_trace(#{argument_list.join(',')}) do
+                  #{without_method_name}(*args, &block)
                  end
               end
             EOC
+
+            visibility = NewRelic::Helper.instance_method_visibility self, method
+
             alias_method without_method_name, method.to_s
             alias_method method.to_s, with_method_name
             send visibility, method
             send visibility, with_method_name
             ::NewRelic::Agent.logger.debug("Traced transaction: class = #{self.name}, method = #{method.to_s}, options = #{options.inspect}")
           end
-        end
 
-        class TransactionNamer
-          def initialize(traced_obj)
-            @traced_obj = traced_obj
-            if (@traced_obj.is_a?(Class) || @traced_obj.is_a?(Module))
-              @traced_class_name = @traced_obj.name
-            else
-              @traced_class_name = @traced_obj.class.name
+          def parse_punctuation(method)
+            [method.to_s.sub(/([?!=])$/, ''), $1]
+          end
+
+          def generate_argument_list(options)
+            options.map do |key, value|
+              value = if value.is_a?(Symbol)
+                value.inspect
+              elsif key == :params
+                value.to_s
+              else
+                %Q["#{value.to_s}"]
+              end
+
+              %Q[:#{key} => #{value}]
             end
           end
 
-          def name(options={})
-            name = "#{category_name(options[:category])}/#{path_name(options)}"
+          def build_method_names(traced_method, punctuation)
+            [ "#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}",
+              "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}" ]
+          end
+
+          def already_added_transaction_tracer?(target, with_method_name)
+            if NewRelic::Helper.instance_methods_include?(target, with_method_name)
+              true
+            else
+              false
+            end
           end
+        end
 
-          def category_name(type = nil)
+        class TransactionNamer
+          def self.category_name(type = nil)
             type ||= Transaction.current && Transaction.current.type
             case type
             when :controller, nil then 'Controller'
@@ -213,6 +220,19 @@ module NewRelic
             end
           end
 
+          def initialize(traced_obj)
+            @traced_obj = traced_obj
+            if (@traced_obj.is_a?(Class) || @traced_obj.is_a?(Module))
+              @traced_class_name = @traced_obj.name
+            else
+              @traced_class_name = @traced_obj.class.name
+            end
+          end
+
+          def name(options={})
+            name = "#{self.class.category_name(options[:category])}/#{path_name(options)}"
+          end
+
           def path_name(options={})
             # if we have the path, use the path
             path = options[:path]
@@ -294,8 +314,6 @@ module NewRelic
         #
         # Seldomly used options:
         #
-        # * <tt>:force => true</tt> indicates you should capture all
-        #   metrics even if the #newrelic_ignore directive was specified
         # * <tt>:class_name => aClass.name</tt> is used to override the name
         #   of the class when used inside the metric name.  Default is the
         #   current class.
@@ -322,16 +340,19 @@ module NewRelic
             end
           end
 
-          txn = _start_transaction(block_given? ? args : [])
+          # If a block was passed in, then the arguments represent options for
+          # the instrumentation, not app method arguments.
+          txn_options = create_transaction_options(block_given? ? args : [])
+          return yield unless NewRelic::Agent.is_execution_traced?
+
+          txn_options[:transaction_name] = TransactionNamer.new(self).name(txn_options)
+          txn_options[:apdex_start_time] = detect_queue_start_time
+
           begin
-            options = { :force => txn.force_flag, :transaction => true }
-            return yield if !(NewRelic::Agent.is_execution_traced? || options[:force])
-            options[:metric] = true if options[:metric].nil?
-            options[:deduct_call_time_from_parent] = true if options[:deduct_call_time_from_parent].nil?
-            _, expected_scope = NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_header(options, txn.start_time.to_f)
+            txn = Transaction.start(txn_options[:category], txn_options)
+            _record_queue_length
 
             begin
-              NewRelic::Agent::BusyCalculator.dispatcher_start txn.start_time
               if block_given?
                 yield
               else
@@ -343,28 +364,12 @@ module NewRelic
             end
 
           ensure
-            end_time = Time.now
-
-            txn.freeze_name
-            metric_names = Array(recorded_metrics(txn))
-            txn_name = metric_names.shift
-
-            NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_footer(txn.start_time.to_f, txn_name, metric_names, expected_scope, options, end_time.to_f)
-            NewRelic::Agent::BusyCalculator.dispatcher_finish(end_time)
-            txn.record_apdex(end_time) unless ignore_apdex?
-            txn = Transaction.stop(txn_name, end_time)
-
-            NewRelic::Agent::TransactionState.get.request_ignore_enduser = true if ignore_enduser?
+            Transaction.stop(Time.now,
+                             :ignore_apdex   => ignore_apdex?,
+                             :ignore_enduser => ignore_enduser?)
           end
         end
 
-        def recorded_metrics(txn)
-          metric_parser = NewRelic::MetricParser::MetricParser.for_metric_named(txn.name)
-          metrics = [txn.name]
-          metrics += metric_parser.summary_metrics unless txn.has_parent?
-          metrics
-        end
-
         protected
 
         def newrelic_request(args)
@@ -417,32 +422,21 @@ module NewRelic
 
         private
 
-        # Write a transaction onto a thread local if there isn't already one there.
-        # If there is one, just update it.
-        def _start_transaction(args) # :nodoc:
-          # If a block was passed in, then the arguments represent options for the instrumentation,
-          # not app method arguments.
-          options = {}
-          if args.any?
-            if args.last.is_a?(Hash)
-              options = args.pop
+        def create_transaction_options(txn_args)
+          txn_options = {}
+          if txn_args.any?
+            if txn_args.last.is_a?(Hash)
+              txn_options = txn_args.pop
             end
-            available_params = options[:params] || {}
-            options[:name] ||= args.first
+            available_params = txn_options[:params] || {}
+            txn_options[:name] ||= txn_args.first
           else
             available_params = self.respond_to?(:params) ? self.params : {}
           end
 
-          options[:request] ||= self.request if self.respond_to? :request
-          options[:filtered_params] = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
-          category = options[:category] || :controller
-          txn = Transaction.start(category, options)
-          txn.name = TransactionNamer.new(self).name(options)
-
-          txn.apdex_start = _detect_upstream_wait(txn)
-          _record_queue_length
-
-          return txn
+          txn_options[:request] ||= self.request if self.respond_to? :request
+          txn_options[:filtered_params] = (respond_to? :filter_parameters) ? filter_parameters(available_params) : available_params
+          txn_options
         end
 
         # Filter out a request if it matches one of our parameters for
@@ -473,20 +467,10 @@ module NewRelic
           end
         end
 
-        # Return a Time instance representing the upstream start time.
-        # now is a Time instance to fall back on if no other candidate
-        # for the start time is found.
-        def _detect_upstream_wait(txn)
-          now = txn.start_time
-          return now unless txn.root?
+        def detect_queue_start_time
           if newrelic_request_headers
-            queue_start = QueueTime.parse_frontend_timestamp(newrelic_request_headers, now)
-            QueueTime.record_frontend_metrics(queue_start, now) if queue_start
+            QueueTime.parse_frontend_timestamp(newrelic_request_headers)
           end
-          queue_start || now
-        rescue => e
-          ::NewRelic::Agent.logger.error("Error detecting upstream wait time:", e)
-          now
         end
       end
     end