dolores_rpm 3.3.4.fork → 3.3.4.1.fork

data/CHANGELOG

@@ -1,5 +1,8 @@
-v3.3.4.fork
-  * Roll back to previous version of DataMapper instrumentation (current one does not work for our app)
+v3.3.4.2
+  * Add additional instrumentation for DataMapper
+
+v3.3.4.1
+ * Bug fix when rendering empty collection in Rails 3.1+
 
 v3.3.4
   * Rails 3 view instrumentation

data/dolores_rpm.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = "dolores_rpm"
-  s.version = "3.3.4.fork"
+  s.version = "3.3.4.1.fork"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bill Kayser", "Jon Guymon", "Justin George", "Darin Swanson"]
-  s.date = "2012-04-27"
-  s.description = "New Relic is a performance management system, developed by New Relic,\nInc (http://www.newrelic.com). This is a fork that uses an older version\nof the DataMapper instrumentation. Newer versions did not work for us.\n"
+  s.date = "2012-05-10"
+  s.description = "New Relic is a performance management system, developed by New Relic,\nInc (http://www.newrelic.com).  New Relic provides you with deep\ninformation about the performance of your web application as it runs\nin production. The New Relic Ruby Agent is dual-purposed as a either a\nGem or plugin, hosted on\nhttp://github.com/newrelic/rpm/\n"
   s.email = "support@newrelic.com"
   s.executables = ["mongrel_rpm", "newrelic", "newrelic_cmd"]
   s.extra_rdoc_files = [
@@ -29,6 +29,7 @@ Gem::Specification.new do |s|
     "cert/cacert.pem",
     "cert/oldsite.pem",
     "cert/site.pem",
+    "dolores_rpm.gemspec",
     "install.rb",
     "lib/conditional_vendored_dependency_detection.rb",
     "lib/conditional_vendored_metric_parser.rb",
@@ -129,7 +130,6 @@ Gem::Specification.new do |s|
     "lib/tasks/install.rake",
     "lib/tasks/tests.rake",
     "newrelic.yml",
-    "dolores_rpm.gemspec",
     "recipes/newrelic.rb",
     "test/active_record_fixtures.rb",
     "test/config/newrelic.yml",

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

@@ -1,57 +1,276 @@
-# NewRelic instrumentation for DataMapper
-# For now, we have to refer to all db metrics as "ActiveRecord"
-if defined? DataMapper
+## 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
   
-  DataMapper::Model.class_eval do
-    add_method_tracer :get, 'ActiveRecord/#{self.name}/find'
-    add_method_tracer :first, 'ActiveRecord/#{self.name}/find'
-    add_method_tracer :first_or_create, 'ActiveRecord/#{self.name}/find'
-    add_method_tracer :all, 'ActiveRecord/#{self.name}/find_all'
+  depends_on do
+    defined?(::DataMapper)
+  end
+
+  depends_on do
+    defined?(DataMapper::Model)
+  end
+
+  depends_on do
+    defined?(DataMapper::Resource)
   end
-  DataMapper::Resource.class_eval do
 
-    @@my_sql_defined = defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
-    @@postgres_defined = defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+  depends_on do
+    defined?(DataMapper::Collection)
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing DataMapper instrumentation'
+  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'
+
+      add_method_tracer :get,    'ActiveRecord/find', :push_scope => false
+      add_method_tracer :first,  'ActiveRecord/find', :push_scope => false
+      add_method_tracer :last,   'ActiveRecord/find', :push_scope => false
+      add_method_tracer :all,    'ActiveRecord/find', :push_scope => false
+      add_method_tracer :create,   'ActiveRecord/save', :push_scope => false
+      add_method_tracer :create!,  'ActiveRecord/save', :push_scope => false
+      add_method_tracer :update,   'ActiveRecord/save', :push_scope => false
+      add_method_tracer :update!,  'ActiveRecord/save', :push_scope => false
+      add_method_tracer :destroy,  'ActiveRecord/destroy', :push_scope => false
+      add_method_tracer :destroy!, 'ActiveRecord/destroy', :push_scope => false
+
+      add_method_tracer :get,      'ActiveRecord/all', :push_scope => false
+      add_method_tracer :first,    'ActiveRecord/all', :push_scope => false
+      add_method_tracer :last,     'ActiveRecord/all', :push_scope => false
+      add_method_tracer :all,      'ActiveRecord/all', :push_scope => false
+      add_method_tracer :create,   'ActiveRecord/all', :push_scope => false
+      add_method_tracer :create!,  'ActiveRecord/all', :push_scope => false
+      add_method_tracer :update,   'ActiveRecord/all', :push_scope => false
+      add_method_tracer :update!,  'ActiveRecord/all', :push_scope => false
+      add_method_tracer :destroy,  'ActiveRecord/all', :push_scope => false
+      add_method_tracer :destroy!, 'ActiveRecord/all', :push_scope => false
+
+      # 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)
+        add_method_tracer(method, 'ActiveRecord/find', :push_scope => false)
+        add_method_tracer(method, 'ActiveRecord/all', :push_scope => false)
+      end
 
-    for method in [:query] do
-      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/execute'
-      add_method_tracer method, 'ActiveRecord/all', :push_scope => false
     end
-    for method in [:update, :save] do
-      add_method_tracer method, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/save'
-      add_method_tracer method, 'ActiveRecord/save', :push_scope => false
+  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'
+
+      add_method_tracer :update,   'ActiveRecord/all', :push_scope => false
+      add_method_tracer :update!,  'ActiveRecord/save', :push_scope => false
+      add_method_tracer :save,     'ActiveRecord/save', :push_scope => false
+      add_method_tracer :save!,    'ActiveRecord/save', :push_scope => false
+      add_method_tracer :destroy,  'ActiveRecord/destroy', :push_scope => false
+      add_method_tracer :destroy!, 'ActiveRecord/destroy', :push_scope => false
+
+      add_method_tracer :update,   'ActiveRecord/all', :push_scope => false
+      add_method_tracer :update!,  'ActiveRecord/all', :push_scope => false
+      add_method_tracer :save,     'ActiveRecord/all', :push_scope => false
+      add_method_tracer :save!,    'ActiveRecord/all', :push_scope => false
+      add_method_tracer :destroy,  'ActiveRecord/all', :push_scope => false
+      add_method_tracer :destroy!, 'ActiveRecord/all', :push_scope => false
     end
-    add_method_tracer :destroy, 'ActiveRecord/#{self.class.name[/[^:]*$/]}/destroy'
-    add_method_tracer :destroy, 'ActiveRecord/destroy', :push_scope => false
-
-    def log_with_newrelic_instrumentation(sql, name, &block)
-      # if we aren't in a blamed context, then add one so that we can
-      # see that controllers are calling SQL directly we check
-      # scope_depth vs 2 since the controller is 1
-      if NewRelic::Agent.instance.transaction_sampler.scope_depth < 2
-        self.class.trace_method_execution "Database/DirectSQL", true, true do
-          log_with_capture_sql(sql, name, &block)
-        end
-      else
-        log_with_capture_sql(sql, name, &block)
+  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)
+        add_method_tracer(method, 'ActiveRecord/find', :push_scope => false
+        add_method_tracer(method, 'ActiveRecord/all', :push_scope => false
       end
+
     end
-    
-    def log_with_capture_sql(sql, name, &block)
-      if @@my_sql_defined && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
-        config = @config
-      elsif @@postgres_defined && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
-        config = @config
-      else
-        config = nil
-      end
-      
-      t0 = Time.now
-      result = log_without_newrelic_instrumentation(sql, name, &block)
-      
-      NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, config, (Time.now - t0).to_f)
-      
-      result
+  end
+end
+
+DependencyDetection.defer do
+
+  depends_on do
+    defined?(DataMapper) && defined?(DataMapper::Adapters) && defined?(DataMapper::Adapters::DataObjectsAdapter)
+  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'
+
+    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'
+    end
+  end
+end
+
+DependencyDetection.defer do
+
+  depends_on do
+    defined?(DataMapper) && defined?(DataMapper::Transaction)
+  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'
+    end
+  end
+end
+
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module DataMapperInstrumentation
+
+        def self.included(klass)
+          klass.class_eval do
+            alias_method :log_without_newrelic_instrumentation, :log
+            alias_method :log, :log_with_newrelic_instrumentation
+          end
+        end
+
+        # Unlike in AR, log is called in DM after the query actually ran,
+        # complete with metrics.  Since DO has already calculated the
+        # duration, there's nothing more to measure, so just record and log.
+        #
+        # We rely on the assumption that all possible entry points have been
+        # hooked with tracers, ensuring that notice_sql attaches this SQL to
+        # the proper call scope.
+        def log_with_newrelic_instrumentation(msg)
+          return unless NewRelic::Agent.is_execution_traced?
+          return unless operation = case 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.
+          NewRelic::Agent.instance.transaction_sampler.notice_sql(msg.query, nil, duration)
+
+          # Record query duration associated with each of the desired metrics.
+          metrics = [ "ActiveRecord/#{operation}", 'ActiveRecord/all' ]
+          metrics.each do |metric|
+            NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric).trace_call(duration)
+          end
+        ensure
+          log_without_newrelic_instrumentation(msg)
+        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

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -43,6 +43,8 @@ module NewRelic
             def template_metric(identifier, options = {})
               if options[:file]
                 "file"
+              elsif identifier.nil?
+                "(unknown)"
               elsif identifier.include? '/' # this is a filepath
                 identifier.split('/')[-2..-1].join('/')
               else
@@ -148,7 +150,8 @@ DependencyDetection.defer do
       def render_with_newrelic(context, options)
         # This is needed for rails 3.2 compatibility
         @details = extract_details(options) if respond_to? :extract_details
-        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(determine_template(options).identifier, options)}/Rendering"
+        identifier = determine_template(options) ? determine_template(options).identifier : nil
+        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier, options)}/Rendering"
         trace_execution_scoped str do
           render_without_newrelic(context, options)
         end
@@ -163,7 +166,8 @@ DependencyDetection.defer do
 
       def render_with_newrelic(*args, &block)
         setup(*args, &block)
-        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(find_partial.identifier)}/Partial"
+        identifier = find_partial ? find_partial.identifier : nil
+        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier)}/Partial"
         trace_execution_scoped str do
           render_without_newrelic(*args, &block)
         end

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -41,6 +41,7 @@ module NewRelic
           if @sample.count_segments == @segment_limit
             NewRelic::Control.instance.log.debug("Segment limit of #{@segment_limit} reached, ceasing collection.")
           end
+          @current_segment
         end
       end
 

data/lib/new_relic/version.rb

@@ -4,7 +4,7 @@ module NewRelic
     MAJOR = 3
     MINOR = 3
     TINY  = 4
-    BUILD = 'fork' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    BUILD = '1.fork' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
 

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -6,6 +6,14 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
     @builder = NewRelic::Agent::TransactionSampleBuilder.new
   end
 
+  # if it doesn't the core app tests will break.  Not strictly necessary but
+  # we'll enforce it with this test for now.
+  def test_trace_entry_returns_segment
+    segment = @builder.trace_entry("/Foo/Bar", Time.now)
+    assert segment, "Segment should not be nil"
+    assert segment.is_a?(NewRelic::TransactionSample::Segment), "Segment should not be a #{segment.class.name}"
+  end
+
   def test_build_sample
     build_segment("a") do
       build_segment("aa") do

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: dolores_rpm
 version: !ruby/object:Gem::Version 
-  hash: -101810583
-  prerelease: 6
+  hash: 1250137308
+  prerelease: 8
   segments: 
   - 3
   - 3
   - 4
+  - 1
   - fork
-  version: 3.3.4.fork
+  version: 3.3.4.1.fork
 platform: ruby
 authors: 
 - Bill Kayser
@@ -19,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-27 00:00:00 Z
+date: 2012-05-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: jeweler
@@ -65,8 +66,11 @@ dependencies:
   version_requirements: *id003
 description: |
   New Relic is a performance management system, developed by New Relic,
-  Inc (http://www.newrelic.com). This is a fork that uses an older version
-  of the DataMapper instrumentation. Newer versions did not work for us.
+  Inc (http://www.newrelic.com).  New Relic provides you with deep
+  information about the performance of your web application as it runs
+  in production. The New Relic Ruby Agent is dual-purposed as a either a
+  Gem or plugin, hosted on
+  http://github.com/newrelic/rpm/
 
 email: support@newrelic.com
 executables: 
@@ -90,6 +94,7 @@ files:
 - cert/cacert.pem
 - cert/oldsite.pem
 - cert/site.pem
+- dolores_rpm.gemspec
 - install.rb
 - lib/conditional_vendored_dependency_detection.rb
 - lib/conditional_vendored_metric_parser.rb
@@ -190,7 +195,6 @@ files:
 - lib/tasks/install.rake
 - lib/tasks/tests.rake
 - newrelic.yml
-- dolores_rpm.gemspec
 - recipes/newrelic.rb
 - test/active_record_fixtures.rb
 - test/config/newrelic.yml