newrelic_rpm 3.7.2.190.beta → 3.7.2.192

data/CHANGELOG

@@ -1,5 +1,53 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.7.2 ##
+
+  * Mongo instrumentation improvements
+
+  Users of the 'mongo' MongoDB client gem will get more detailed instrumentation
+  including support for some operations that were not previously captured, and
+  separation of aggregate metrics for web transactions from background jobs.
+
+  An issue with ensure_index when passed a symbol or string was also fixed.
+  Thanks Maxime RETY for the report!
+
+  * More accurate error tracing in Rails 4
+
+  Traced errors in Rails 4 applications will now be correctly associated with
+  the transaction they occurred in, and custom attributes attached to the
+  transaction will be correctly attached to the traced error as well.
+
+  * More accurate partial-rendering metrics for Rails 4
+
+  View partials are now correctly treated as sub-components of the containing
+  template render in Rails 4 applications, meaning that the app server breakdown
+  graphs for Rails 4 transactions should be more accurate and useful.
+
+  * Improved Unicorn 4.8.0 compatibility
+
+  A rare issue that could lead to spurrious traced errors on app startup for
+  applications using Unicorn 4.8.0 has been fixed.
+
+  * meta_request gem compatibility
+
+  An incompatibility with the meta_request gem has been fixed.
+
+  * Typhoeus 0.6.4+ compatibility
+
+  A potential crash with Typhoeus 0.6.4+ when passing a URI object instead of a
+  String instance to one of Typhoeus's HTTP request methods has been fixed.
+
+  * Sequel single threaded mode fix
+
+  The agent will no longer attempt to run EXPLAIN queries for slow SQL
+  statements issued using the Sequel gem in single-threaded mode, since
+  doing so could potentially cause crashes.
+
+  * Additional functionality for add_custom_parameters
+
+  Calling add_custom_parameters adds parameters to the system codenamed
+  Rubicon. For more information, see http://newrelic.com/software-analytics
+
 ## v3.7.1 ##
 
   * MongoDB support

data/LICENSE

@@ -112,7 +112,7 @@ the software.
 
 
 All other components of this product are
-Copyright (c) 2008-2013 New Relic, Inc.  All rights reserved.
+Copyright (c) 2008-2014 New Relic, Inc.  All rights reserved.
 
 Certain inventions disclosed in this file may be claimed within
 patents owned or patent applications filed by New Relic, Inc. or third

data/lib/new_relic/agent/configuration/default_source.rb

@@ -624,12 +624,6 @@ module NewRelic
           :type => Boolean,
           :description => 'Enable or disable sequel instrumentation.'
         },
-        :override_sql_obfuscation_adapter => {
-          :default => '',
-          :public => true,
-          :type => String,
-          :description => "Override for the sql obfuscation adapter."
-        },
         :disable_database_instrumentation => {
           :default => false,
           :public => true,

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -106,13 +106,14 @@ module NewRelic
 
       def insert_response_header(request_headers, response_headers)
         unless client_cross_app_id.nil?
-          NewRelic::Agent::Transaction.freeze_name
-          timings = NewRelic::Agent::TransactionState.get.timings
-          content_length = content_length_from_request(request_headers)
-
-          set_response_headers(response_headers, timings, content_length)
-          set_metrics(client_cross_app_id, timings)
+          unless NewRelic::Agent::TransactionState.get.transaction.nil?
+            NewRelic::Agent::Transaction.freeze_name
+            timings = NewRelic::Agent::TransactionState.get.timings
+            content_length = content_length_from_request(request_headers)
 
+            set_response_headers(response_headers, timings, content_length)
+            set_metrics(client_cross_app_id, timings)
+          end
           clear_client_cross_app_id
         end
       end

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

@@ -17,6 +17,14 @@ module NewRelic
             end
 
             NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(name, payload, request_type)
+          rescue => e
+            NewRelic::Agent.logger.debug("Failure during Mongo metric generation", e)
+            []
+          end
+
+          def self.generate_instance_metric_for(host, port, database_name)
+            return unless host && port && database_name
+            NewRelic::Agent::Datastores::Mongo::MetricTranslator.instance_metric(host, port, database_name)
           end
         end
       end

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

@@ -10,16 +10,15 @@ module NewRelic
       module Mongo
         module MetricTranslator
           def self.metrics_for(name, payload, request_type = :web)
-            payload = {} if payload.nil?
+            payload ||= {}
 
+            database = payload[:database]
             collection = payload[:collection]
 
             if collection_in_selector?(collection, payload)
               command_key = command_key_from_selector(payload)
-
-              name = get_name_from_selector(command_key)
-              collection = get_collection_from_selector(command_key, payload)
-              log_if_unknown_command(command_key, payload)
+              name        = get_name_from_selector(command_key, payload)
+              collection  = get_collection_from_selector(command_key, payload)
             end
 
             if self.find_one?(name, payload)
@@ -43,22 +42,21 @@ module NewRelic
             elsif self.rename_collection?(name, payload)
               name = 'renameCollection'
               collection = collection_name_from_rename_selector(payload)
-            elsif self.ismaster?(name, payload)
-              name = 'ismaster'
-              collection = collection_name_from_ismaster_selector(payload)
             end
 
-            build_metrics(name, collection, request_type)
+            metrics = build_metrics(name, collection, request_type)
+
+            metrics
           end
 
           def self.build_metrics(name, collection, request_type = :web)
             default_metrics = [
               "Datastore/statement/MongoDB/#{collection}/#{name}",
-              "Datastore/operation/MongoDB/#{name}",
-              'ActiveRecord/all'
+              "Datastore/operation/MongoDB/#{name}"
             ]
 
             if request_type == :web
+              default_metrics << 'ActiveRecord/all'
               default_metrics << 'Datastore/allWeb'
             else
               default_metrics << 'Datastore/allOther'
@@ -67,6 +65,10 @@ module NewRelic
             default_metrics
           end
 
+          def self.instance_metric(host, port, database)
+            "Datastore/instance/MongoDB/#{host}:#{port}/#{database}"
+          end
+
           def self.collection_in_selector?(collection, payload)
             collection == '$cmd' && payload[:selector]
           end
@@ -84,15 +86,11 @@ module NewRelic
             :deleteIndexes,
             :reIndex,
 
-            :ismaster,
             :collstats,
             :renameCollection,
             :drop,
           ]
 
-          UNKNOWN_COMMAND = "UnknownCommand"
-          UNKNOWN_COLLECTION = "UnknownCollection"
-
           def self.command_key_from_selector(payload)
             selector = payload[:selector]
             NAMES_IN_SELECTOR.find do |check_name|
@@ -100,22 +98,23 @@ module NewRelic
             end
           end
 
-          def self.get_name_from_selector(command_key)
-            return UNKNOWN_COMMAND unless command_key
-
-            command_key.to_sym
+          def self.get_name_from_selector(command_key, payload)
+            if command_key
+              command_key.to_sym
+            else
+              NewRelic::Agent.increment_metric("Supportability/Mongo/UnknownCollection")
+              payload[:selector].first.first unless command_key
+            end
           end
 
-          def self.get_collection_from_selector(command_key, payload)
-            return UNKNOWN_COLLECTION unless command_key
+          CMD_COLLECTION = "$cmd".freeze
 
-            payload[:selector][command_key]
-          end
-
-          def self.log_if_unknown_command(command_key, payload)
-            unless command_key
-              NewRelic::Agent.logger.debug("Unknown Mongo command: #{Obfuscator.obfuscate_statement(payload).inspect}")
-              NewRelic::Agent.increment_metric("Supportability/Mongo/UnknownCommand")
+          def self.get_collection_from_selector(command_key, payload)
+            if command_key
+              payload[:selector][command_key]
+            else
+              NewRelic::Agent.increment_metric("Supportability/Mongo/UnknownCollection")
+              CMD_COLLECTION
             end
           end
 
@@ -155,10 +154,6 @@ module NewRelic
             name == :renameCollection
           end
 
-          def self.ismaster?(name, payload)
-            name == :ismaster
-          end
-
           def self.collection_name_from_index(payload)
             if payload[:documents] && payload[:documents].first[:ns]
               payload[:documents].first[:ns].split('.').last
@@ -177,10 +172,6 @@ module NewRelic
             parts.join('.')
           end
 
-          def self.collection_name_from_ismaster_selector(payload)
-            payload[:selector][:ismaster]
-          end
-
         end
 
       end

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

@@ -418,22 +418,32 @@ module NewRelic
         def perform_action_with_newrelic_profile(args)
           txn = _start_transaction(block_given? ? args : [])
           val = nil
-          NewRelic::Agent.trace_execution_scoped txn.metric_name do
-            NewRelic::Agent.disable_all_tracing do
-              # turn on profiling
-              profile = RubyProf.profile do
-                if block_given?
-                  val = yield
-                else
-                  val = perform_action_without_newrelic_trace(*args)
-                end
+          options = { :metric => true }
+
+          _, expected_scope = NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_header(options, txn.start_time.to_f)
+
+          NewRelic::Agent.disable_all_tracing do
+            # turn on profiling
+            profile = RubyProf.profile do
+              if block_given?
+                val = yield
+              else
+                val = perform_action_without_newrelic_trace(*args)
               end
-              NewRelic::Agent.instance.transaction_sampler.notice_profile profile
             end
+            NewRelic::Agent.instance.transaction_sampler.notice_profile profile
           end
+
           return val
         ensure
-          txn.pop
+          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)
+
+          txn = Transaction.stop(txn_name, end_time)
         end
 
         # Write a transaction onto a thread local if there isn't already one there.

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

@@ -28,37 +28,66 @@ DependencyDetection.defer do
   end
 
   def install_mongo_instrumentation
+    setup_logging_for_instrumentation
     instrument_mongo_logging
     instrument_save
     instrument_ensure_index
   end
 
-  def instrument_mongo_logging
+  def setup_logging_for_instrumentation
     ::Mongo::Logging.class_eval do
       include NewRelic::Agent::MethodTracer
       require 'new_relic/agent/datastores/mongo/metric_generator'
       require 'new_relic/agent/datastores/mongo/statement_formatter'
 
-      def instrument_with_new_relic_trace(name, payload = {}, &block)
-        metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(name, payload)
-
-        trace_execution_scoped(metrics) do
-          t0 = Time.now
-          result = instrument_without_new_relic_trace(name, payload, &block)
-
-          payload[:operation] = name
-          statement = NewRelic::Agent::Datastores::Mongo::StatementFormatter.format(payload)
-          if statement
-            NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(statement, (Time.now - t0).to_f)
+      def new_relic_instance_metric_builder
+        Proc.new do
+          if @pool
+            host, port = @pool.host, @pool.port
+          elsif @connection && (primary = @connection.primary)
+            host, port = primary[0], primary[1]
           end
 
-          result
+          database_name = @db.name if @db
+          NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for(host, port, database_name)
+        end
+      end
+
+      # It's key that this method eats all exceptions, as it rests between the
+      # Mongo operation the user called and us returning them the data. Be safe!
+      def new_relic_notice_statement(t0, payload, operation)
+        payload[:operation] = operation
+        statement = NewRelic::Agent::Datastores::Mongo::StatementFormatter.format(payload)
+        if statement
+          NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(statement, (Time.now - t0).to_f)
         end
+      rescue => e
+        NewRelic::Agent.logger.debug("Exception during Mongo statement gathering", e)
+      end
+
+      def new_relic_generate_metrics(operation, payload = nil)
+        payload ||= { :collection => self.name, :database => self.db.name }
+        metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(operation, payload)
       end
 
       ::Mongo::Collection.class_eval { include Mongo::Logging; }
       ::Mongo::Connection.class_eval { include Mongo::Logging; }
       ::Mongo::Cursor.class_eval { include Mongo::Logging; }
+    end
+  end
+
+  def instrument_mongo_logging
+    ::Mongo::Logging.class_eval do
+      def instrument_with_new_relic_trace(name, payload = {}, &block)
+        metrics = new_relic_generate_metrics(name, payload)
+
+        trace_execution_scoped(metrics, :additional_metrics_callback => new_relic_instance_metric_builder) do
+          t0 = Time.now
+          result = instrument_without_new_relic_trace(name, payload, &block)
+          new_relic_notice_statement(t0, payload, name)
+          result
+        end
+      end
 
       alias_method :instrument_without_new_relic_trace, :instrument
       alias_method :instrument, :instrument_with_new_relic_trace
@@ -67,14 +96,9 @@ DependencyDetection.defer do
 
   def instrument_save
     ::Mongo::Collection.class_eval do
-      include NewRelic::Agent::MethodTracer
-      require 'new_relic/agent/datastores/mongo/metric_generator'
-      require 'new_relic/agent/datastores/mongo/statement_formatter'
-
       def save_with_new_relic_trace(doc, opts = {}, &block)
-        metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:save, { :collection => self.name })
-
-        trace_execution_scoped(metrics) do
+        metrics = new_relic_generate_metrics(:save)
+        trace_execution_scoped(metrics, :additional_metrics_callback => new_relic_instance_metric_builder) do
           t0 = Time.now
 
           transaction_state = NewRelic::Agent::TransactionState.get
@@ -86,12 +110,7 @@ DependencyDetection.defer do
             transaction_state.pop_traced
           end
 
-          doc[:operation] = :save
-          statement = NewRelic::Agent::Datastores::Mongo::StatementFormatter.format(doc)
-          if statement
-            NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(statement, (Time.now - t0).to_f)
-          end
-
+          new_relic_notice_statement(t0, doc, :save)
           result
         end
       end
@@ -103,14 +122,9 @@ DependencyDetection.defer do
 
   def instrument_ensure_index
     ::Mongo::Collection.class_eval do
-      include NewRelic::Agent::MethodTracer
-      require 'new_relic/agent/datastores/mongo/metric_generator'
-      require 'new_relic/agent/datastores/mongo/statement_formatter'
-
       def ensure_index_with_new_relic_trace(spec, opts = {}, &block)
-        metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:ensureIndex, { :collection => self.name })
-
-        trace_execution_scoped(metrics) do
+        metrics = new_relic_generate_metrics(:ensureIndex)
+        trace_execution_scoped(metrics, :additional_metrics_callback => new_relic_instance_metric_builder) do
           t0 = Time.now
 
           transaction_state = NewRelic::Agent::TransactionState.get
@@ -122,14 +136,16 @@ DependencyDetection.defer do
             transaction_state.pop_traced
           end
 
-          spec = spec.is_a?(Array) ? Hash[spec] : spec.dup
-          spec[:operation] = :ensureIndex
-
-          statement = NewRelic::Agent::Datastores::Mongo::StatementFormatter.format(spec)
-          if statement
-            NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(statement, (Time.now - t0).to_f)
-          end
+          spec = case spec
+                 when Array
+                   Hash[spec]
+                 when String, Symbol
+                   { spec => 1 }
+                 else
+                   spec.dup
+                 end
 
+          new_relic_notice_statement(t0, spec, :ensureIndex)
           result
         end
       end

data/lib/new_relic/agent/method_tracer.rb

@@ -267,13 +267,20 @@ module NewRelic
       #
       def trace_execution_scoped(metric_names, options={})
         return yield if trace_disabled?(options)
-        set_if_nil(options, :metric)
-        set_if_nil(options, :deduct_call_time_from_parent)
+
         metric_names = Array(metric_names)
         first_name = metric_names.shift
+        return yield if first_name.nil?
+
+        set_if_nil(options, :metric)
+        set_if_nil(options, :deduct_call_time_from_parent)
+        additional_metrics_callback = options[:additional_metrics_callback]
         start_time, expected_scope = trace_execution_scoped_header(options)
+
         begin
-          yield
+          result = yield
+          metric_names += Array(additional_metrics_callback.call) if additional_metrics_callback
+          result
         ensure
           trace_execution_scoped_footer(start_time, first_name, metric_names, expected_scope, options)
         end