newrelic_rpm 3.10.0.279 → 3.11.0.283

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

@@ -2,186 +2,147 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-## NewRelic instrumentation for DataMapper
-#
-# Instrumenting DM has different key challenges versus AR:
-#
-#   1. The hooking of SQL logging in DM is decoupled from any knowledge of the
-#      Model#method that invoked it.  But on the positive side, the duration is
-#      already calculated for you (and it happens inside the C-based DO code, so
-#      it's faster than a Ruby equivalent).
-#
-#   2. There are a lot more entry points that need to be hooked in order to
-#      understand call flow: DM::Model (model class) vs. DM::Resource (model
-#      instance) vs. DM::Collection (collection of model instances).  And
-#      others.
-#
-#   3. Strategic Eager Loading (SEL) combined with separately-grouped
-#      lazy-loaded attributes presents a unique problem for tying resulting
-#      SEL-invoked SQL calls to their proper scope.
-#
-# NOTE: On using "Database" versus "ActiveRecord" as base metric name
-#
-#   Using "Database" as the metric name base seems to properly identify methods
-#   as being DB-related in call graphs, but certain New Relic views that show
-#   aggregations of DB CPM, etc still seem to rely solely on "ActiveRecord"
-#   being the base name, thus AFAICT "Database" calls to this are lost.  (Though
-#   I haven't yet tested "Database/SQL/{find/save/destroy/all}" yet, as it seems
-#   like an intuitively good name to use.)
-#
-#   So far I think these are the rules:
-#
-#     - ActiveRecord/{find/save/destroy} populates "Database Throughput" and
-#       "Database Response Time" in the Database tab. [non-scoped]
-#
-#     - ActiveRecord/all populates the main Overview tab of DB time.  (still
-#       unsure about this one). [non-scoped]
-#
-#     These metrics are represented as :push_scope => false or included as the
-#     non-first metric in trace_execution_scoped() (docs say only first counts
-#     towards scope) so they don't show up ine normal call graph/trace.
-
 DependencyDetection.defer do
-  @name = :data_mapper
-
-  depends_on do
-    defined?(::DataMapper)
-  end
+  named :data_mapper
 
   depends_on do
-    defined?(DataMapper::Model)
-  end
-
-  depends_on do
-    defined?(DataMapper::Resource)
-  end
-
-  depends_on do
-    defined?(DataMapper::Collection)
+    defined?(::DataMapper) &&
+      defined?(::DataMapper::Model) &&
+      defined?(::DataMapper::Resource) &&
+      defined?(::DataMapper::Collection)
   end
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing DataMapper instrumentation'
+    require 'new_relic/agent/datastores/metric_helper'
   end
 
   executes do
-    DataMapper::Model.class_eval do
-      add_method_tracer :get,      'ActiveRecord/#{self.name}/get'
-      add_method_tracer :first,    'ActiveRecord/#{self.name}/first'
-      add_method_tracer :last,     'ActiveRecord/#{self.name}/last'
-      add_method_tracer :all,      'ActiveRecord/#{self.name}/all'
-
-      add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
-      add_method_tracer :create!,  'ActiveRecord/#{self.name}/create'
-      add_method_tracer :update,   'ActiveRecord/#{self.name}/update'
-      add_method_tracer :update!,  'ActiveRecord/#{self.name}/update'
-      add_method_tracer :destroy,  'ActiveRecord/#{self.name}/destroy'
-      add_method_tracer :destroy!, 'ActiveRecord/#{self.name}/destroy'
-
-      # For dm-aggregates and partial dm-ar-finders support:
-      for method in [ :aggregate, :find, :find_by_sql ] do
-        next unless method_defined? method
-        add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
-      end
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :get
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :first
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :last
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :all
 
-    end
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :create
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :create!
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :update
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :update!
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :destroy
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :destroy!
+
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :aggregate
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :find
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Model, :find_by_sql
   end
 
   executes do
-    DataMapper::Resource.class_eval do
-      add_method_tracer :update,   'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
-      add_method_tracer :update!,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/update'
-      add_method_tracer :save,     'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
-      add_method_tracer :save!,    'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
-      add_method_tracer :destroy,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
-      add_method_tracer :destroy!, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
-
-    end
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :update
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :update!
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :save
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :save!
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :destroy
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Resource, :destroy!
   end
 
   executes do
-    DataMapper::Collection.class_eval do
-      # DM's Collection instance methods
-      add_method_tracer :get,       'ActiveRecord/#{self.name}/get'
-      add_method_tracer :first,     'ActiveRecord/#{self.name}/first'
-      add_method_tracer :last,      'ActiveRecord/#{self.name}/last'
-      add_method_tracer :all,       'ActiveRecord/#{self.name}/all'
-
-      add_method_tracer :lazy_load, 'ActiveRecord/#{self.name}/lazy_load'
-
-      add_method_tracer :create,    'ActiveRecord/#{self.name}/create'
-      add_method_tracer :create!,   'ActiveRecord/#{self.name}/create'
-      add_method_tracer :update,    'ActiveRecord/#{self.name}/update'
-      add_method_tracer :update!,   'ActiveRecord/#{self.name}/update'
-      add_method_tracer :destroy,   'ActiveRecord/#{self.name}/destroy'
-      add_method_tracer :destroy!,  'ActiveRecord/#{self.name}/destroy'
-
-      # For dm-aggregates support:
-      for method in [ :aggregate ] do
-        next unless method_defined? method
-        add_method_tracer(method, 'ActiveRecord/#{self.name}/' + method.to_s)
-      end
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :get
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :first
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :last
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :all
 
-    end
-  end
-end
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :lazy_load
 
-DependencyDetection.defer do
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :create
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :create!
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :update
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :update!
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :destroy
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :destroy!
 
-  depends_on do
-    defined?(DataMapper) && defined?(DataMapper::Adapters) && defined?(DataMapper::Adapters::DataObjectsAdapter)
+    NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Collection, :aggregate
   end
 
   executes do
-
-    # Catch the two entry points into DM::Repository::Adapter that bypass CRUD
-    # (for when SQL is run directly).
-    DataMapper::Adapters::DataObjectsAdapter.class_eval do
-
-      add_method_tracer :select,  'ActiveRecord/#{self.class.name[/[^:]*$/]}/select'
-      add_method_tracer :execute, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute'
-
+    # Catch direct SQL calls that bypass CRUD
+    if defined?(::DataMapper::Adapters::DataObjectsAdapter)
+      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Adapters::DataObjectsAdapter, :select, true
+      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Adapters::DataObjectsAdapter, :execute, true
     end
   end
-end
 
-DependencyDetection.defer do
-
-  depends_on do
-    defined?(DataMapper) && defined?(DataMapper::Validations) && defined?(DataMapper::Validations::ClassMethods)
-  end
-
-  # DM::Validations overrides Model#create, but currently in a way that makes it
-  # impossible to instrument from one place.  I've got a patch pending inclusion
-  # to make it instrumentable by putting the create method inside ClassMethods.
-  # This will pick it up if/when that patch is accepted.
   executes do
-    DataMapper::Validations::ClassMethods.class_eval do
-      next unless method_defined? :create
-      add_method_tracer :create,   'ActiveRecord/#{self.name}/create'
+    # DM::Validations overrides Model#create, so we patch it here as well
+    if defined?(::DataMapper::Validations::ClassMethods)
+      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Validations::ClassMethods, :create
     end
   end
-end
-
-DependencyDetection.defer do
 
-  depends_on do
-    defined?(DataMapper) && defined?(DataMapper::Transaction)
+  executes do
+    # DM::Transaction calls commit() twice, so potentially shows up twice.
+    if defined?(::DataMapper::Transaction)
+      NewRelic::Agent::DataMapperTracing.add_tracer ::DataMapper::Transaction, :commit, true
+    end
   end
 
-  # NOTE: DM::Transaction basically calls commit() twice, so as-is it will show
-  # up in traces twice -- second time subordinate to the first's scope.  Works
-  # well enough.
   executes do
-    DataMapper::Transaction.module_eval do
-      add_method_tracer :commit, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/commit'
+    if defined?(::DataObjects::Connection)
+      ::DataObjects::Connection.class_eval do
+        include ::NewRelic::Agent::Instrumentation::DataMapperInstrumentation
+      end
     end
   end
 end
 
-
 module NewRelic
   module Agent
+    module DataMapperTracing
+      def self.add_tracer(clazz, method_name, operation_only = false)
+        clazz.class_eval do
+          if method_defined?(method_name) || private_method_defined?(method_name)
+            define_method("#{method_name}_with_newrelic",
+                          NewRelic::Agent::DataMapperTracing.method_body(clazz, method_name, operation_only))
+
+            alias_method "#{method_name}_without_newrelic", method_name
+            alias_method method_name, "#{method_name}_with_newrelic"
+          end
+        end
+      end
+
+      DATA_MAPPER = "DataMapper".freeze
+
+      def self.method_body(clazz, method_name, operation_only)
+        use_model_name   = NewRelic::Helper.instance_methods_include?(clazz, :model)
+        metric_operation = method_name.to_s.gsub(/[!?]/, "")
+
+        Proc.new do |*args, &blk|
+          begin
+            if operation_only
+              # Used by direct SQL, like ::DataMapper::Adapters::DataObjectsAdapter#select
+              name = nil
+            elsif use_model_name
+              # Used by ::DataMapper::Collection to get contained model name
+              name = self.model.name
+            elsif self.is_a?(Class)
+              # Used by class-style access, like Model.first()
+              name = self.name
+            else
+              # Used by instance-style access, like model.update(attr: "new")
+              name = self.class.name
+            end
+
+            metrics = NewRelic::Agent::Datastores::MetricHelper.metrics_for(
+              DATA_MAPPER,
+              metric_operation,
+              name)
+
+            NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
+              self.send("#{method_name}_without_newrelic", *args, &blk)
+            end
+          end
+        end
+      end
+    end
+
     module Instrumentation
       module DataMapperInstrumentation
         # Unlike in AR, log is called in DM after the query actually ran,
@@ -194,42 +155,13 @@ module NewRelic
         def log(msg) #THREAD_LOCAL_ACCESS
           state = NewRelic::Agent::TransactionState.tl_get
           return unless state.is_execution_traced?
-          return unless operation = case NewRelic::Helper.correctly_encoded(msg.query)
-                                    when /^\s*select/i          then 'find'
-                                    when /^\s*(update|insert)/i then 'save'
-                                    when /^\s*delete/i          then 'destroy'
-                                    else nil
-                                    end
-
-          # FYI: self.to_s will yield connection URI string.
-          duration = msg.duration / 1000000.0
 
-          # Attach SQL to current segment/scope.
+          duration = msg.duration / 1000000.0
           NewRelic::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration, state)
-
-          # Record query duration associated with each of the desired metrics.
-          metric = "ActiveRecord/#{operation}"
-          rollup_metrics = ActiveRecordHelper.rollup_metrics_for(metric)
-          metrics = [metric] + rollup_metrics
-          NewRelic::Agent.instance.stats_engine.tl_record_unscoped_metrics(metrics, duration)
         ensure
           super
         end
-
-      end # DataMapperInstrumentation
-    end # Instrumentation
-  end # Agent
-end # NewRelic
-
-DependencyDetection.defer do
-
-  depends_on do
-    defined?(DataObjects) && defined?(DataObjects::Connection)
-  end
-
-  executes do
-    DataObjects::Connection.class_eval do
-      include ::NewRelic::Agent::Instrumentation::DataMapperInstrumentation
+      end
     end
   end
 end

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

@@ -9,83 +9,135 @@
 #     http://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
 #     http://github.com/mperham/dalli (Gem: dalli)
 
+require 'new_relic/agent/datastores/metric_helper'
+
 module NewRelic
   module Agent
     module Instrumentation
       module Memcache
         module_function
-        def instrument_methods(the_class, method_names)
-          method_names.each do |method_name|
-            next unless the_class.method_defined?(method_name.to_sym) || the_class.private_method_defined?(method_name.to_sym)
-            visibility = "private" unless the_class.method_defined?(method_name.to_sym)
-            the_class.class_eval <<-EOD
-              #{visibility}
-              def #{method_name}_with_newrelic_trace(*args, &block)
-                metrics = ["Memcache/#{method_name}",
-                           (NewRelic::Agent::Transaction.recording_web_transaction? ? 'Memcache/allWeb' : 'Memcache/allOther')]
-                self.class.trace_execution_scoped(metrics) do
+
+        def enabled?
+          !::NewRelic::Agent.config[:disable_memcache_instrumentation]
+        end
+
+        METHODS = [:get, :get_multi, :set, :add, :incr, :decr, :delete, :replace, :append,
+                   :prepend, :cas, :single_get, :multi_get, :single_cas, :multi_cas]
+
+        def supported_methods_for(client_class, methods)
+          methods.select do |method_name|
+            client_class.method_defined?(method_name) || client_class.private_method_defined?(method_name)
+          end
+        end
+
+        def instrument_methods(client_class, requested_methods = METHODS)
+          supported_methods_for(client_class, requested_methods).each do |method_name|
+
+            visibility = NewRelic::Helper.instance_method_visibility client_class, method_name
+            method_name_without = :"#{method_name}_without_newrelic_trace"
+
+            client_class.class_eval do
+              alias_method method_name_without, method_name
+
+              define_method method_name do |*args, &block|
+                metrics = Datastores::MetricHelper.metrics_for("Memcached", method_name)
+
+                NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
                   t0 = Time.now
                   begin
-                    #{method_name}_without_newrelic_trace(*args, &block)
+                    send method_name_without, *args, &block
                   ensure
-                    #{memcache_key_snippet(method_name)}
+                    if NewRelic::Agent.config[:capture_memcache_keys]
+                      NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil
+                    end
                   end
                 end
               end
-              alias #{method_name}_without_newrelic_trace #{method_name}
-              alias #{method_name} #{method_name}_with_newrelic_trace
-            EOD
-         end
-        end
-        def memcache_key_snippet(method_name)
-          return "" unless NewRelic::Agent.config[:capture_memcache_keys]
-          "NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil"
+
+              send visibility, method_name
+              send visibility, method_name_without
+            end
+          end
         end
+
       end
     end
   end
 end
 
 DependencyDetection.defer do
-  @name = :memcache
+  named :memcache_client
 
   depends_on do
-    !NewRelic::Agent.config[:disable_memcache_instrumentation]
+    NewRelic::Agent::Instrumentation::Memcache.enabled?
   end
 
   depends_on do
-    defined?(::MemCache) || defined?(::Memcached) ||
-      defined?(::Dalli::Client) || defined?(::Spymemcached)
+    defined?(::MemCache)
   end
 
   executes do
-    commands = %w[get get_multi set add incr decr delete replace append prepend]
-    if defined? ::MemCache
-      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::MemCache,
-                                                                    commands)
-      ::NewRelic::Agent.logger.info 'Installing MemCache instrumentation'
-    end
-    if defined? ::Memcached
-      if ::Memcached::VERSION >= '1.8.0'
-        commands -= %w[get get_multi]
-        commands += %w[single_get multi_get single_cas multi_cas]
-      else
-        commands << 'cas'
-      end
-      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Memcached,
-                                                                    commands)
-      ::NewRelic::Agent.logger.info 'Installing Memcached instrumentation'
-    end
-    if defined? ::Dalli::Client
-      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client,
-                                                                    commands)
-      ::NewRelic::Agent.logger.info 'Installing Dalli Memcache instrumentation'
-    end
-    if defined? ::Spymemcached
-      commands << 'multiget'
-      NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Spymemcached,
-                                                                    commands)
-      ::NewRelic::Agent.logger.info 'Installing Spymemcached instrumentation'
-    end
+    ::NewRelic::Agent.logger.info 'Installing Memcached instrumentation for memcache-client gem'
+    NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::MemCache)
+  end
+end
+
+DependencyDetection.defer do
+  named :memcached
+
+  depends_on do
+    NewRelic::Agent::Instrumentation::Memcache.enabled?
+  end
+
+  depends_on do
+    defined?(::Memcached)
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Memcached instrumentation for memcached gem'
+    ::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