newrelic_rpm 3.17.0.325 → 3.17.1.326

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d92e44197eda26fe761484451437f731e71bbb1
-  data.tar.gz: f1c0e0554ed45e78c7d42b6617a1c98dbb7a3d3f
+  metadata.gz: 96d6b5b5c5bd88e9ac89be8715dfcfafd77ed814
+  data.tar.gz: 48b63cdd1ab3637281a7879cf1ec88625819a940
 SHA512:
-  metadata.gz: 92827c74e5109b6d2fd3ba456af3af0d410328b8ff5224a9ee4858e8139fa328cb5128d2fc43c316bca415b5366dca59f691473222c28c620e000c08bd17a79d
-  data.tar.gz: be6bd6121731993cd243c607d21a0eabab546c74c106bcf4a7a37da66a471d68311e5b67df6ca4301a07a0e7253cf20c6aeb4fb32859c34889224e77f26a088b
+  metadata.gz: 813384949da5fcfdc76d7ad7a7c1ad610bacccd854f96dcfe80d5078a371598a1769cb4bd6ec9e91b42cfffc0af6f2367ffb9cc3e2588612fd383dc75b64a014
+  data.tar.gz: eb33cc2fd802490ebeeb30ed104d41111f2d58484b15bc60d00055c5051b3c5009b1a9a90adcdd2145a7287e75b45af4871429a3ac0a74563fa502e7125691bc

data/CHANGELOG

@@ -1,5 +1,26 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.17.1 ##
+
+  * Datastore instance reporting for Redis, MongoDB, and memcached
+
+  The agent now collects datastore instance information for Redis, MongoDB,
+  and memcached. This information is displayed in transaction traces and slow
+  query traces. For memcached only, multi requests will expand to individual
+  server nodes, and the operation and key(s) will show in the trace details
+  "Database query" section. Metrics for `get_multi` nodes will change slightly.
+  Parent nodes for a `get_multi` will be recorded as generic segments. Their
+  children will be recorded as datastore segments under the name
+  `get_multi_request` and represent a batch request to a single Memcached
+  instance.
+
+  * Rescue errors from attempts to fetch slow query explain plans
+
+  For slow queries through ActiveRecord 4+, the agent will attempt to fetch
+  an explain plan on SELECT statements. In the event that this causes an
+  error, such as being run on an adapter that doesn't implement `exec_query`,
+  the agent will now rescue and log those errors.
+
 ## v3.17.0 ##
 
   * Datastore instance reporting for ActiveRecord

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

@@ -84,21 +84,13 @@ module NewRelic
           [product, operation, collection]
         end
 
-        def self.metrics_for(product, operation, collection = nil, generic_product = nil)
+        def self.metrics_for(product, operation, collection = nil, generic_product = nil, host=nil, port_path_or_id=nil)
           product, operation, collection = product_operation_collection_for(product, operation, collection, generic_product)
-          suffix = all_suffix
 
           # Order of these metrics matters--the first metric in the list will
           # be treated as the scoped metric in a bunch of different cases.
-          metrics = [
-            operation_metric_for(product, operation),
-            product_suffixed_rollup(product, suffix),
-            product_rollup(product),
-            suffixed_rollup(suffix),
-            ROLLUP_METRIC
-          ]
-
-          metrics.unshift statement_metric_for(product, collection, operation) if collection
+          metrics = unscoped_metrics_for(product, operation, collection, host, port_path_or_id)
+          metrics.unshift scoped_metric_for(product, operation, collection)
 
           metrics
         end

data/lib/new_relic/agent/hostname.rb

@@ -25,6 +25,24 @@ module NewRelic
       def self.get_dyno_prefixes
         ::NewRelic::Agent.config[:'heroku.dyno_name_prefixes_to_shorten']
       end
+
+      LOCALHOST = %w[
+        localhost
+        0.0.0.0
+        127.0.0.1
+        0:0:0:0:0:0:0:1
+        0:0:0:0:0:0:0:0
+        ::1
+        ::
+      ].freeze
+
+      def self.local? host_or_ip
+        LOCALHOST.include?(host_or_ip)
+      end
+
+      def self.get_external host_or_ip
+        local?(host_or_ip) ? get : host_or_ip
+      end
     end
   end
 end

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

@@ -55,13 +55,9 @@ module NewRelic
           database = nil
 
           if ActiveRecordHelper::InstanceIdentification.supported_adapter?(@config)
-            if NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
-              host = ActiveRecordHelper::InstanceIdentification.host(@config)
-              port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(@config)
-            end
-            if NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
-              database = @config && @config[:database]
-            end
+            host = ActiveRecordHelper::InstanceIdentification.host(@config)
+            port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(@config)
+            database = @config && @config[:database]
           end
 
           segment = NewRelic::Agent::Transaction.start_datastore_segment(product, operation, collection, host, port_path_or_id, database)

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

@@ -207,16 +207,6 @@ module NewRelic
         module InstanceIdentification
           extend self
 
-          LOCALHOST = %w[
-            localhost
-            0.0.0.0
-            127.0.0.1
-            0:0:0:0:0:0:0:1
-            0:0:0:0:0:0:0:0
-            ::1
-            ::
-          ].freeze unless defined?(LOCALHOST)
-
           PRODUCT_SYMBOLS = {
             "mysql"      => :mysql,
             "mysql2"     => :mysql,
@@ -241,7 +231,7 @@ module NewRelic
             configured_value  = config[:host]
             adapter = PRODUCT_SYMBOLS[config[:adapter]]
             if configured_value.nil? ||
-              LOCALHOST.include?(configured_value) ||
+              Hostname.local?(configured_value) ||
               postgres_unix_domain_socket_case?(configured_value, adapter)
 
               Hostname.get
@@ -250,6 +240,10 @@ module NewRelic
             else
               configured_value
             end
+
+          rescue => e
+            NewRelic::Agent.logger.debug "Failed to retrieve ActiveRecord host: #{e}"
+            UNKNOWN
           end
 
           def port_path_or_id(config)
@@ -267,6 +261,10 @@ module NewRelic
             else
               UNKNOWN
             end
+
+          rescue => e
+            NewRelic::Agent.logger.debug "Failed to retrieve ActiveRecord port_path_or_id: #{e}"
+            UNKNOWN
           end
 
           SUPPORTED_ADAPTERS = [:mysql, :postgres].freeze unless defined?(SUPPORTED_ADAPTERS)
@@ -283,7 +281,7 @@ module NewRelic
 
           def mysql_default_case?(config, adapter)
             (adapter == :mysql2 || adapter == :mysql) &&
-              LOCALHOST.include?(config[:host]) &&
+              Hostname.local?(config[:host]) &&
               !config[:port]
           end
         end

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

@@ -50,6 +50,8 @@ module NewRelic
                                          "Explain #{statement.name}",
                                          statement.binds)
           end
+        rescue => e
+          NewRelic::Agent.logger.debug "Couldn't fetch the explain plan for #{statement} due to #{e}"
         end
 
         def active_record_config(payload)
@@ -91,13 +93,9 @@ module NewRelic
             database = nil
 
             if ActiveRecordHelper::InstanceIdentification.supported_adapter?(@config)
-              if NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
-                host = ActiveRecordHelper::InstanceIdentification.host(@config)
-                port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(@config)
-              end
-              if NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
-                database = @config && @config[:database]
-              end
+              host = ActiveRecordHelper::InstanceIdentification.host(@config)
+              port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(@config)
+              database = @config && @config[:database]
             end
 
             segment = NewRelic::Agent::Transaction::DatastoreSegment.new product, operation, collection, host, port_path_or_id, database

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

@@ -10,6 +10,7 @@
 #     https://github.com/mperham/dalli (Gem: dalli)
 
 require 'new_relic/agent/datastores/metric_helper'
+require 'new_relic/agent/instrumentation/memcache/dalli'
 
 module NewRelic
   module Agent
@@ -45,8 +46,7 @@ module NewRelic
                   send method_name_without, *args, &block
                 ensure
                   if NewRelic::Agent.config[:capture_memcache_keys]
-                    NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect,
-                                                                              (Time.now - segment.start_time).to_f) rescue nil
+                    segment.notice_nosql_statement "#{method_name} #{args.first.inspect}"
                   end
                   segment.finish
                 end
@@ -96,46 +96,3 @@ DependencyDetection.defer do
     ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Memcached)
   end
 end
-
-DependencyDetection.defer do
-  named :dalli
-
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
-
-  depends_on do
-    defined?(::Dalli::Client)
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Memcache instrumentation for dalli gem'
-    ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client)
-  end
-end
-
-DependencyDetection.defer do
-  named :dalli_cas_client
-
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
-
-  depends_on do
-    # These CAS client methods are only optionally defined if users require
-    # dalli/cas/client. Use a separate dependency block so it can potentially
-    # re-evaluate after they've done that require.
-    defined?(::Dalli::Client) &&
-      ::NewRelic::Agent::Instrumentation::Memcache.supported_methods_for(::Dalli::Client,
-                                                                         CAS_CLIENT_METHODS).any?
-  end
-
-  CAS_CLIENT_METHODS = [:get_cas, :get_multi_cas, :set_cas, :replace_cas,
-                        :delete_cas]
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Dalli CAS Client Memcache instrumentation'
-    ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client,
-                                                                    CAS_CLIENT_METHODS)
-  end
-end

data/lib/new_relic/agent/instrumentation/memcache/dalli.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Memcache
+        module Dalli
+          extend self
+
+          MEMCACHED = "Memcached".freeze
+          METHODS = [:get, :set, :add, :incr, :decr, :delete, :replace, :append, :prepend, :cas]
+          SEND_MULTIGET_METRIC_NAME = "get_multi_request".freeze
+          DATASTORE_INSTANCES_SUPPORTED_VERSION = ::NewRelic::VersionNumber.new '2.6.4'
+          SLASH = '/'.freeze
+          UNKNOWN = 'unknown'.freeze
+
+          def supports_datastore_instances?
+            DATASTORE_INSTANCES_SUPPORTED_VERSION <= ::Dalli::VERSION
+          end
+
+          def instrument_methods
+            if supports_datastore_instances?
+              ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client, METHODS)
+              instrument_multi_method :get_multi
+              instrument_send_multiget
+              instrument_server_for_key
+            else
+              ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client,
+                ::NewRelic::Agent::Instrumentation::Memcache::METHODS)
+            end
+          end
+
+          def instrument_server_for_key
+            ::Dalli::Ring.class_eval do
+              alias_method :server_for_key_without_newrelic_trace, :server_for_key
+
+              def server_for_key key
+                server = server_for_key_without_newrelic_trace key
+                begin
+                  if txn = ::NewRelic::Agent::Transaction.tl_current
+                    segment = txn.current_segment
+                    if ::NewRelic::Agent::Transaction::DatastoreSegment === segment
+                      ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
+                    end
+                  end
+                rescue => e
+                  ::NewRelic::Agent.logger.warn "Unable to set instance info on datastore segment: #{e.message}"
+                end
+                server
+              end
+            end
+          end
+
+          def instrument_send_multiget
+            ::Dalli::Server.class_eval do
+              alias_method :send_multiget_without_newrelic_trace, :send_multiget
+
+              def send_multiget(keys)
+                segment = ::NewRelic::Agent::Transaction.start_datastore_segment(MEMCACHED, SEND_MULTIGET_METRIC_NAME)
+                ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, self)
+
+                begin
+                  send_multiget_without_newrelic_trace(keys)
+                ensure
+                  if ::NewRelic::Agent.config[:capture_memcache_keys]
+                    segment.notice_nosql_statement "#{SEND_MULTIGET_METRIC_NAME} #{keys.inspect}"
+                  end
+                  segment.finish
+                end
+              end
+            end
+          end
+
+          def instrument_multi_method method_name
+            visibility = NewRelic::Helper.instance_method_visibility ::Dalli::Client, method_name
+            method_name_without = :"#{method_name}_without_newrelic_trace"
+
+            ::Dalli::Client.class_eval do
+              alias_method method_name_without, method_name
+
+              define_method method_name do |*args, &block|
+                segment = NewRelic::Agent::Transaction.start_segment "Ruby/Memcached/Dalli/#{method_name}"
+                begin
+                  __send__ method_name_without, *args, &block
+                ensure
+                  segment.finish
+                end
+              end
+
+              __send__ visibility, method_name
+              __send__ visibility, method_name_without
+            end
+          end
+
+          def assign_instance_to segment, server
+            if server.hostname.start_with? SLASH
+              segment.host = ::NewRelic::Agent::Hostname.get
+              segment.port_path_or_id = server.hostname
+            else
+              segment.host = ::NewRelic::Agent::Hostname.get_external server.hostname
+              segment.port_path_or_id = server.port
+            end
+          rescue => e
+            ::NewRelic::Agent.logger.debug "Failed to retrieve memcached instance info: #{e.message}"
+            segment.host = UNKNOWN
+            segment.port_path_or_id = UNKNOWN
+          end
+
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  named :dalli
+
+  depends_on do
+    NewRelic::Agent::Instrumentation::Memcache.enabled?
+  end
+
+  depends_on do
+    defined?(::Dalli::Client)
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Memcache instrumentation for dalli gem'
+    ::NewRelic::Agent::Instrumentation::Memcache::Dalli.instrument_methods
+  end
+end
+
+DependencyDetection.defer do
+  named :dalli_cas_client
+
+  depends_on do
+    NewRelic::Agent::Instrumentation::Memcache.enabled?
+  end
+
+  depends_on do
+    # These CAS client methods are only optionally defined if users require
+    # dalli/cas/client. Use a separate dependency block so it can potentially
+    # re-evaluate after they've done that require.
+    defined?(::Dalli::Client) &&
+      ::NewRelic::Agent::Instrumentation::Memcache.supported_methods_for(::Dalli::Client,
+                                                                         CAS_CLIENT_METHODS).any?
+  end
+
+  CAS_CLIENT_METHODS = [:get_cas, :set_cas, :replace_cas, :delete_cas]
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Dalli CAS Client Memcache instrumentation'
+    ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client, CAS_CLIENT_METHODS)
+    ::NewRelic::Agent::Instrumentation::Memcache::Dalli.instrument_multi_method(:get_multi_cas)
+  end
+end

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

@@ -14,7 +14,6 @@ module NewRelic
           begin
             return unless NewRelic::Agent.tl_is_execution_traced?
             segments[event.operation_id] = start_segment event
-            operations[event.operation_id] = event
           rescue Exception => e
             log_notification_error('started', e)
           end
@@ -24,9 +23,7 @@ module NewRelic
           begin
             state = NewRelic::Agent::TransactionState.tl_get
             return unless state.is_execution_traced?
-            started_event = operations.delete(event.operation_id)
             segment = segments.delete(event.operation_id)
-            notice_nosql_statement(state, started_event, segment.name, event.duration)
             segment.finish
           rescue Exception => e
             log_notification_error('completed', e)
@@ -39,28 +36,24 @@ module NewRelic
         private
 
         def start_segment event
-          NewRelic::Agent::Transaction.start_datastore_segment(
-            MONGODB, event.command_name, collection(event)
+          host = host_from_address event.address
+          port_path_or_id = port_path_or_id_from_address event.address
+          segment = NewRelic::Agent::Transaction.start_datastore_segment(
+            MONGODB, event.command_name, collection(event), host, port_path_or_id, event.database_name
           )
+          segment.notice_nosql_statement(generate_statement(event))
+          segment
         end
 
         def collection(event)
           event.command[COLLECTION] || event.command[:collection] || event.command.values.first
         end
 
-        def metrics(event)
-          NewRelic::Agent::Datastores::MetricHelper.metrics_for(MONGODB, event.command_name, collection(event))
-        end
-
         def log_notification_error(event_type, error)
           NewRelic::Agent.logger.error("Error during MongoDB #{event_type} event:")
           NewRelic::Agent.logger.log_exception(:error, error)
         end
 
-        def operations
-          @operations ||= {}
-        end
-
         def segments
           @segments ||= {}
         end
@@ -73,10 +66,34 @@ module NewRelic
           )
         end
 
-        def notice_nosql_statement(state, event, metric, duration)
-          NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(
-              generate_statement(event), duration
-            )
+        UNKNOWN = "unknown".freeze
+
+        def host_from_address(address)
+          if unix_domain_socket? address.host
+            Hostname.get
+          else
+            Hostname.get_external address.host
+          end
+        rescue => e
+          NewRelic::Agent.logger.debug "Failed to retrieve Mongo host: #{e}"
+          UNKNOWN
+        end
+
+        def port_path_or_id_from_address(address)
+          if unix_domain_socket? address.host
+            address.host
+          else
+            address.port
+          end
+        rescue => e
+          NewRelic::Agent.logger.debug "Failed to retrieve Mongo port_path_or_id: #{e}"
+          UNKNOWN
+        end
+
+        SLASH = "/".freeze
+
+        def unix_domain_socket?(host)
+          host.start_with? SLASH
         end
       end
     end