newrelic_rpm 3.3.0 → 3.3.1.beta1

data/CHANGELOG

@@ -1,3 +1,7 @@
+v3.3.1
+  * improved Ruby 1.8.6 support
+  * fix for issues with RAILS_ROOT deprecation warnings
+
 v3.3.0
   * fix for GC instrumentation when using Ruby 1.9
   * new feature to correlate browser and server transaction traces

data/lib/new_relic/agent/agent.rb

@@ -1048,7 +1048,7 @@ module NewRelic
           # FIXME add the code to try to resend if our connection is down
           sql_traces = @sql_sampler.harvest
           unless sql_traces.empty?
-            log.debug "Sending (#{sql_traces.count}) sql traces"
+            log.debug "Sending (#{sql_traces.size}) sql traces"
             begin
               response = invoke_remote :sql_trace_data, sql_traces
 #              log.debug "Sql trace response: #{response}"

data/lib/new_relic/agent/database.rb

@@ -35,14 +35,6 @@ module NewRelic
         ConnectionManager.instance.close_connections
       end
       
-      def config
-        ConnectionManager.instance.config
-      end
-      
-      def config=(other)
-        ConnectionManager.instance.config = other
-      end
-
       # Perform this in the runtime environment of a managed
       # application, to explain the sql statement executed within a
       # segment of a transaction sample. Returns an array of
@@ -119,12 +111,10 @@ module NewRelic
         first_word, rest_of_statement = statement.split($;, 2)
         (first_word.upcase == 'SELECT')
       end
-
+      
       class ConnectionManager
         include Singleton
 
-        attr_accessor :config
-        
         # Returns a cached connection for a given ActiveRecord
         # configuration - these are stored or reopened as needed, and if
         # we cannot get one, we ignore it and move on without explaining

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

@@ -0,0 +1,137 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecord
+        def self.included(instrumented_class)
+          instrumented_class.class_eval do
+            unless instrumented_class.method_defined?(:log_without_newrelic_instrumentation)
+              alias_method :log_without_newrelic_instrumentation, :log
+              alias_method :log, :log_with_newrelic_instrumentation
+              protected :log
+            end
+          end
+        end
+                
+        def log_with_newrelic_instrumentation(*args, &block)
+          if !NewRelic::Agent.is_execution_traced?
+            return log_without_newrelic_instrumentation(*args, &block)
+          end
+          
+          sql, name, binds = args
+          metric = metric_for_name(name) || metric_for_sql(sql)
+          
+          if !metric
+            log_without_newrelic_instrumentation(*args, &block)
+          else
+            metrics = [metric, remote_service_metric].compact
+            metrics += rollup_metrics_for(metric)
+            self.class.trace_execution_scoped(metrics) do
+              t0 = Time.now
+              begin
+                log_without_newrelic_instrumentation(*args, &block)
+              ensure
+                elapsed_time = (Time.now - t0).to_f
+                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql,
+                                                         @config, elapsed_time)
+                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric,
+                                                         @config, elapsed_time)
+              end
+            end
+          end
+        end
+        
+        def remote_service_metric
+          if @config && @config[:adapter]
+            type = @config[:adapter].sub(/\d*/, '')
+            host = @config[:host] || 'localhost'
+            "RemoteService/sql/#{type}/#{host}"
+          end                      
+        end
+        
+        def metric_for_name(name)
+          if name && (parts = name.split " ") && parts.size == 2
+            model = parts.first
+            operation = parts.last.downcase
+            op_name = case operation
+                          when 'load', 'count', 'exists' then 'find'
+                          when 'indexes', 'columns' then nil # fall back to DirectSQL
+                          when 'destroy', 'find', 'save', 'create' then operation
+                          when 'update' then 'save'
+                          else
+                            if model == 'Join'
+                              operation
+                            end
+                          end
+            "ActiveRecord/#{model}/#{op_name}" if op_name
+          end
+        end
+
+        def metric_for_sql(sql)
+          metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
+          if metric.nil?
+            if sql =~ /^(select|update|insert|delete|show)/i
+              # Could not determine the model/operation so let's find a better
+              # metric.  If it doesn't match the regex, it's probably a show
+              # command or some DDL which we'll ignore.
+              metric = "Database/SQL/#{$1.downcase}"
+            else
+              metric = "Database/SQL/other"
+            end
+          end
+          metric
+        end
+        
+        def rollup_metrics_for(metric)
+          metrics = ["ActiveRecord/all"]
+          metrics << "ActiveRecord/#{$1}" if metric =~ /ActiveRecord\/\w+\/(\w+)/
+          metrics
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :active_record
+  
+  depends_on do
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base)
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['skip_ar_instrumentation']
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['disable_activerecord_instrumentation']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing ActiveRecord instrumentation'
+  end
+  
+  executes do
+    if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+      Rails.configuration.after_initialize do
+        insert_instrumentation
+      end
+    else
+      insert_instrumentation
+    end
+  end
+
+  def insert_instrumentation
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+      include ::NewRelic::Agent::Instrumentation::ActiveRecord
+    end
+    
+    ActiveRecord::Base.class_eval do
+      class << self
+        add_method_tracer(:find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql',
+                          :metric => false)
+        add_method_tracer(:transaction, 'ActiveRecord/#{self.name}/transaction',
+                          :metric => false)
+      end
+    end          
+  end
+end

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

@@ -231,6 +231,7 @@ module NewRelic
         # If a single argument is passed in, it is treated as a metric
         # path.  This form is deprecated.
         def perform_action_with_newrelic_trace(*args, &block)
+          NewRelic::Agent::TransactionInfo.clear
 
           # Skip instrumentation based on the value of 'do_not_trace' and if
           # we aren't calling directly with a block.

data/lib/new_relic/agent/sql_sampler.rb

@@ -95,9 +95,9 @@ module NewRelic
         data = transaction_data
         clear_transaction_data
 
-        if data.sql_data.count > 0
+        if data.sql_data.size > 0
           @samples_lock.synchronize do
-            NewRelic::Agent.instance.log.debug "Harvesting #{data.sql_data.count} slow transaction sql statement(s)"
+            NewRelic::Agent.instance.log.debug "Harvesting #{data.sql_data.size} slow transaction sql statement(s)"
             #FIXME get tx name and uri
             harvest_slow_sql data
           end

data/lib/new_relic/data_serialization.rb

@@ -14,7 +14,8 @@ module NewRelic
       # (handled elsewhere)
       def should_send_data?
         NewRelic::Control.instance.disable_serialization? || store_too_large? ||
-          store_too_old? || pid_too_old?
+          store_too_old? || pid_too_old? ||
+          NewRelic::LanguageSupport.using_version?('1.8.6')
       rescue Exception => e
         NewRelic::Control.instance.disable_serialization = true
         NewRelic::Control.instance.log.warn("Disabling serialization: #{e.message}")

data/lib/new_relic/delayed_job_injection.rb

@@ -43,4 +43,9 @@ DependencyDetection.defer do
     end
   end
 end
-DependencyDetection.detect!
+
+# If Rails is defined, this gets called in an after_initialize hook
+# see NewRelic::Control::Frameworks::Rails#init_config
+unless defined?(Rails)
+  DependencyDetection.detect!
+end

data/lib/new_relic/version.rb

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

data/newrelic_rpm.gemspec

@@ -5,14 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = "newrelic_rpm"
-  s.version = "3.3.0"
+  s.version = "3.3.1.beta1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bill Kayser", "Jon Guymon", "Justin George", "Darin Swanson"]
-  s.date = "2011-11-07"
+  s.date = "2011-11-11"
   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 = ["newrelic_cmd", "newrelic", "mongrel_rpm"]
+  s.executables = ["mongrel_rpm", "newrelic", "newrelic_cmd"]
   s.extra_rdoc_files = [
     "CHANGELOG",
     "LICENSE",
@@ -42,6 +42,7 @@ Gem::Specification.new do |s|
     "lib/new_relic/agent/error_collector.rb",
     "lib/new_relic/agent/instrumentation.rb",
     "lib/new_relic/agent/instrumentation/active_merchant.rb",
+    "lib/new_relic/agent/instrumentation/active_record.rb",
     "lib/new_relic/agent/instrumentation/acts_as_solr.rb",
     "lib/new_relic/agent/instrumentation/authlogic.rb",
     "lib/new_relic/agent/instrumentation/controller_instrumentation.rb",
@@ -58,10 +59,8 @@ Gem::Specification.new do |s|
     "lib/new_relic/agent/instrumentation/rack.rb",
     "lib/new_relic/agent/instrumentation/rails/action_controller.rb",
     "lib/new_relic/agent/instrumentation/rails/action_web_service.rb",
-    "lib/new_relic/agent/instrumentation/rails/active_record_instrumentation.rb",
     "lib/new_relic/agent/instrumentation/rails/errors.rb",
     "lib/new_relic/agent/instrumentation/rails3/action_controller.rb",
-    "lib/new_relic/agent/instrumentation/rails3/active_record_instrumentation.rb",
     "lib/new_relic/agent/instrumentation/rails3/errors.rb",
     "lib/new_relic/agent/instrumentation/sinatra.rb",
     "lib/new_relic/agent/instrumentation/sunspot.rb",

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -21,6 +21,25 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     mocha_teardown
   end
 
+  def test_browser_monitoring_start_time_is_reset_each_request
+    controller = Object.new
+    def controller.perform_action_without_newrelic_trace(method, options={});
+      # noop; instrument me
+    end
+    def controller.newrelic_metric_path; "foo"; end
+    controller.extend ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    controller.extend ::NewRelic::Agent::BrowserMonitoring
+
+    controller.perform_action_with_newrelic_trace(:index)
+    first_request_start_time = controller.send(:browser_monitoring_start_time)
+    controller.perform_action_with_newrelic_trace(:index)
+    second_request_start_time = controller.send(:browser_monitoring_start_time)
+
+    # assert that these aren't the same time object
+    # the start time should be reinitialized each request to the controller
+    assert !(first_request_start_time.equal? second_request_start_time)
+  end
+
   def test_browser_timing_header_with_no_beacon_configuration
     NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
     header = browser_timing_header

data/test/new_relic/agent/instrumentation/active_record_instrumentation_test.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
 class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::Unit::TestCase
   require 'active_record_fixtures'
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
@@ -139,20 +140,22 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   def test_metric_names_standard
     # fails due to a bug in rails 3 - log does not provide the correct
     # transaction type - it returns 'SQL' instead of 'Foo Create', for example.
-    return if rails3? || defined?(JRuby) || isSqlite?
-
+    return if defined?(JRuby) || isSqlite?
+    
     expected = %W[
       ActiveRecord/all
       ActiveRecord/find
-      ActiveRecord/ActiveRecordFixtures::Order/find
       ActiveRecord/create
+      ActiveRecord/ActiveRecordFixtures::Order/find
+      ActiveRecord/ActiveRecordFixtures::Order/create
       Database/SQL/other
-      RemoteService/sql/mysql/localhost      
-      ActiveRecord/ActiveRecordFixtures::Order/create]
+      RemoteService/sql/mysql/localhost]
 
     if NewRelic::Control.instance.rails_version < '2.1.0'
       expected += ['ActiveRecord/save',
                    'ActiveRecord/ActiveRecordFixtures::Order/save']
+    elsif NewRelic::Control.instance.rails_version >= '3.0.0'
+      expected << 'Database/SQL/insert'
     end
 
     assert_calls_metrics(*expected) do
@@ -163,10 +166,14 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     end
 
     metrics = NewRelic::Agent.instance.stats_engine.metrics
-
+        
     compare_metrics expected, metrics
     check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/find", 1)
-    check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/create", 1)
+    if NewRelic::Control.instance.rails_version < '3.0.0'
+      check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/create", 1)
+    else
+      check_metric_count("Database/SQL/insert", 1)
+    end
   end
 
   def test_join_metrics_jruby
@@ -346,6 +353,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     metrics = NewRelic::Agent.instance.stats_engine.metrics
     compare_metrics [], metrics
   end
+  
   def test_run_explains
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
@@ -353,10 +361,12 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     end
 
     # that's a mouthful. perhaps we should ponder our API.
-    segment = NewRelic::Agent.instance.transaction_sampler.last_sample.root_segment.called_segments.first.called_segments.first.called_segments.first
+    segment = NewRelic::Agent.instance.transaction_sampler.last_sample \
+      .root_segment.called_segments[0].called_segments[0].called_segments[0]
     regex = /^SELECT (["`]?#{ActiveRecordFixtures::Order.table_name}["`]?.)?\* FROM ["`]?#{ActiveRecordFixtures::Order.table_name}["`]?$/
     assert_match regex, segment.params[:sql].strip
   end
+  
   def test_prepare_to_send
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
@@ -517,7 +527,31 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       assert_equal 'preserve-me!', e.message
     end
   end
-
+  
+  def test_remote_service_metric_respects_dynamic_connection_config
+    return unless isMysql?
+
+#     puts NewRelic::Agent::Database.config.inspect
+    
+    ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
+    assert(NewRelic::Agent.get_stats('RemoteService/sql/mysql/localhost').call_count != 0)
+
+    config = ActiveRecordFixtures::Shipment.connection.instance_eval { @config }    
+    config[:host] = '127.0.0.1'
+    connection = ActiveRecordFixtures::Shipment.establish_connection(config)
+    
+#     puts ActiveRecord::Base.connection.instance_eval { @config }.inspect
+#     puts NewRelic::Agent::Database.config.inspect
+    
+    ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
+    assert(NewRelic::Agent.get_stats('RemoteService/sql/mysql/127.0.0.1').call_count != 0)
+
+    config[:host] = 'localhost'
+    ActiveRecordFixtures::Shipment.establish_connection(config)
+
+#     raise NewRelic::Agent.instance.stats_engine.inspect
+  end
+  
   private
 
   def rails3?
@@ -538,5 +572,4 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   def isSqlite?
     ActiveRecord::Base.configurations[rails_env]['adapter'] =~ /sqlite/i
   end
-
 end

data/test/new_relic/agent/instrumentation/queue_time_test.rb

@@ -270,20 +270,15 @@ class NewRelic::Agent::Instrumentation::QueueTimeTest < Test::Unit::TestCase
     check_metric_time('WebFrontend/QueueTime', 0.0, 0.001)
   end
 
-
-  # check all the combinations to make sure that ordering doesn't
-  # affect the return value
   def test_find_oldest_time
-    test_arrays = [
+    test_array = [
+                   ['c', Time.at(1002)],                   
                    ['a', Time.at(1000)],
                    ['b', Time.at(1001)],
-                   ['c', Time.at(1002)],
                    ['d', Time.at(1000)],
                   ]
-    test_arrays = test_arrays.permutation
-    test_arrays.each do |test_array|
-      assert_equal find_oldest_time(test_array), Time.at(1000), "Should be the oldest time in the array"
-    end
+    assert_equal(find_oldest_time(test_array), Time.at(1000),
+                 "Should be the oldest time in the array")
   end
 
   # trivial test but the method doesn't do much

data/test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb

@@ -104,7 +104,7 @@ module NewRelic
             end
 
             def test_check_for_illegal_keys_negative
-              test_keys = Hash[ALLOWED_KEYS.map {|x| [x, nil]}]
+              test_keys = Hash[*ALLOWED_KEYS.map {|x| [x, nil]}.flatten]
               check_for_illegal_keys!(test_keys)
             end
 

data/test/new_relic/agent/rpm_agent_test.rb

@@ -82,7 +82,7 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
 
     should "send_timeslice_data" do
       # this test fails due to a rubinius bug
-      return if (RUBY_DESCRIPTION =~ /rubinius/i)
+      return if NewRelic::LanguageSupport.using_engine?('rbx')
       @agent.expects(:invoke_remote).returns({NewRelic::MetricSpec.new("/A/b/c") => 1, NewRelic::MetricSpec.new("/A/b/c", "/X") => 2, NewRelic::MetricSpec.new("/A/b/d") => 3 }.to_a)
       @agent.send :harvest_and_send_timeslice_data
       assert_equal 3, @agent.metric_ids.size

data/test/new_relic/agent/sql_sampler_test.rb

@@ -31,7 +31,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     # this sql will not be captured
     @sampler.notice_sql "select * from test", "Database/test/select", nil, 0
     assert_not_nil @sampler.transaction_data
-    assert_equal 2, @sampler.transaction_data.sql_data.count
+    assert_equal 2, @sampler.transaction_data.sql_data.size
   end
   
   def test_harvest_slow_sql
@@ -45,7 +45,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     ]
     @sampler.harvest_slow_sql data
       
-    assert_equal 2, @sampler.sql_traces.count
+    assert_equal 2, @sampler.sql_traces.size
   end
   
   def test_sql_aggregation
@@ -73,7 +73,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     @sampler.harvest_slow_sql data
       
     sql_traces = @sampler.harvest
-    assert_equal 2, sql_traces.count
+    assert_equal 2, sql_traces.size
   end
 
   def test_harvest_should_not_take_more_than_10
@@ -104,7 +104,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     @sampler.harvest_slow_sql data
       
     sql_traces = @sampler.harvest
-    assert_equal 2, sql_traces.count    
+    assert_equal 2, sql_traces.size
   end
 
   def test_harvest_should_collect_explain_plans

data/test/new_relic/control_test.rb

@@ -22,6 +22,7 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   # testing that the CA file we ship actually validates our server's
   # certificate. It's used for customers who enable verify_certificate
   def test_cert_file
+    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 
@@ -38,6 +39,7 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   # certificates in a non-customer-facing place before setting them
   # live.
   def test_staging_cert_file
+    return if ::RUBY_VERSION == '1.9.3'
     require 'socket'
     require 'openssl'
 

data/test/new_relic/data_serialization_test.rb

@@ -151,6 +151,7 @@ class NewRelic::DataSerializationTest < Test::Unit::TestCase
   end
 
   def test_loading_does_not_seg_fault_if_gc_triggers
+    return if NewRelic::LanguageSupport.using_version?('1.8.6')
     require 'timeout'
     
     Thread.abort_on_exception = true

metadata

@@ -1,15 +1,10 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: newrelic_rpm
-version: !ruby/object:Gem::Version 
-  hash: 11
-  prerelease: 
-  segments: 
-  - 3
-  - 3
-  - 0
-  version: 3.3.0
+version: !ruby/object:Gem::Version
+  version: 3.3.1.beta1
+  prerelease: 6
 platform: ruby
-authors: 
+authors:
 - Bill Kayser
 - Jon Guymon
 - Justin George
@@ -17,72 +12,66 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-11-07 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: jeweler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2152161920 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: mocha
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2152161920
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &2152161440 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: shoulda
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *2152161440
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &2152160940 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-description: |
-  New Relic is a performance management system, developed by New Relic,
+  prerelease: false
+  version_requirements: *2152160940
+description: ! 'New Relic is a performance management system, developed by New Relic,
+
   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: 
-- newrelic_cmd
-- newrelic
+executables:
 - mongrel_rpm
+- newrelic
+- newrelic_cmd
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - CHANGELOG
 - LICENSE
 - README.rdoc
 - newrelic.yml
-files: 
+files:
 - CHANGELOG
 - LICENSE
 - README.rdoc
@@ -105,6 +94,7 @@ files:
 - lib/new_relic/agent/error_collector.rb
 - lib/new_relic/agent/instrumentation.rb
 - lib/new_relic/agent/instrumentation/active_merchant.rb
+- lib/new_relic/agent/instrumentation/active_record.rb
 - lib/new_relic/agent/instrumentation/acts_as_solr.rb
 - lib/new_relic/agent/instrumentation/authlogic.rb
 - lib/new_relic/agent/instrumentation/controller_instrumentation.rb
@@ -121,10 +111,8 @@ files:
 - lib/new_relic/agent/instrumentation/rack.rb
 - lib/new_relic/agent/instrumentation/rails/action_controller.rb
 - lib/new_relic/agent/instrumentation/rails/action_web_service.rb
-- lib/new_relic/agent/instrumentation/rails/active_record_instrumentation.rb
 - lib/new_relic/agent/instrumentation/rails/errors.rb
 - lib/new_relic/agent/instrumentation/rails3/action_controller.rb
-- lib/new_relic/agent/instrumentation/rails3/active_record_instrumentation.rb
 - lib/new_relic/agent/instrumentation/rails3/errors.rb
 - lib/new_relic/agent/instrumentation/sinatra.rb
 - lib/new_relic/agent/instrumentation/sunspot.rb
@@ -344,61 +332,38 @@ files:
 - vendor/gems/metric_parser-0.1.0.pre1/lib/new_relic/metric_parser/web_transaction.rb
 homepage: http://www.github.com/newrelic/rpm
 licenses: []
-
-post_install_message: |
-  
-  PLEASE NOTE:
-  
-  Developer Mode is now a Rack middleware.
-  
-  Developer Mode is no longer available in Rails 2.1 and earlier.
-  However, starting in version 2.12 you can use Developer Mode in any
-  Rack based framework, in addition to Rails.  To install developer mode
-  in a non-Rails application, just add NewRelic::Rack::DeveloperMode to
-  your middleware stack.
-  
-  If you are using JRuby, we recommend using at least version 1.4 or 
-  later because of issues with the implementation of the timeout library.
-  
-  Refer to the README.md file for more information.
-  
-  Please see http://github.com/newrelic/rpm/blob/master/CHANGELOG
-  for a complete description of the features and enhancements available
-  in version 3.3 of the Ruby Agent.
-    
-
-rdoc_options: 
+post_install_message: ! "\nPLEASE NOTE:\n\nDeveloper Mode is now a Rack middleware.\n\nDeveloper
+  Mode is no longer available in Rails 2.1 and earlier.\nHowever, starting in version
+  2.12 you can use Developer Mode in any\nRack based framework, in addition to Rails.
+  \ To install developer mode\nin a non-Rails application, just add NewRelic::Rack::DeveloperMode
+  to\nyour middleware stack.\n\nIf you are using JRuby, we recommend using at least
+  version 1.4 or \nlater because of issues with the implementation of the timeout
+  library.\n\nRefer to the README.md file for more information.\n\nPlease see http://github.com/newrelic/rpm/blob/master/CHANGELOG\nfor
+  a complete description of the features and enhancements available\nin version 3.3
+  of the Ruby Agent.\n  \n"
+rdoc_options:
 - --line-numbers
 - --inline-source
 - --title
 - New Relic Ruby Agent
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: New Relic Ruby Agent
 test_files: []
-
-has_rdoc: 

data/lib/new_relic/agent/instrumentation/rails/active_record_instrumentation.rb

@@ -1,118 +0,0 @@
-module NewRelic
-  module Agent
-    module Instrumentation
-      module ActiveRecordInstrumentation
-
-        def self.included(instrumented_class)
-          instrumented_class.class_eval do
-            alias_method :log_without_newrelic_instrumentation, :log
-            alias_method :log, :log_with_newrelic_instrumentation
-            protected :log
-          end          
-        end
-        
-        def log_with_newrelic_instrumentation(sql, name, &block)
-          return log_without_newrelic_instrumentation(sql, name, &block) unless NewRelic::Agent.is_execution_traced?
-          
-          if name && (parts = name.split " ") && parts.size == 2
-            model = parts.first
-            operation = parts.last.downcase
-            metric_name = case operation
-                          when 'load' then 'find'
-                          when 'indexes', 'columns' then nil # fall back to DirectSQL
-                          when 'destroy', 'find', 'save', 'create' then operation
-                          when 'update' then 'save'
-                          else
-                            if model == 'Join'
-                              operation
-                            end
-                          end
-            metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
-          end
-
-          if metric.nil?
-            metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
-            if metric.nil?
-              if sql =~ /^(select|update|insert|delete|show)/i
-                # Could not determine the model/operation so let's find a better
-                # metric.  If it doesn't match the regex, it's probably a show
-                # command or some DDL which we'll ignore.
-                metric = "Database/SQL/#{$1.downcase}"
-              else
-                metric = "Database/SQL/other"
-              end
-            end
-          end
-
-          if !metric
-            log_without_newrelic_instrumentation(sql, name, &block)
-          else
-            metrics = [metric, "ActiveRecord/all"]
-            metrics << "ActiveRecord/#{metric_name}" if metric_name
-            if NewRelic::Agent::Database.config && NewRelic::Agent::Database.config[:adapter]
-              type = NewRelic::Agent::Database.config[:adapter].sub(/\d*/, '')
-              host = NewRelic::Agent::Database.config[:host] || 'localhost'
-              metrics << "RemoteService/sql/#{type}/#{host}"
-            end
-            
-            self.class.trace_execution_scoped(metrics) do
-              t0 = Time.now
-              begin
-                log_without_newrelic_instrumentation(sql, name, &block)
-              ensure
-                elapsed_time = (Time.now - t0).to_f
-                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, NewRelic::Agent::Database.config,
-                                                                        elapsed_time)
-                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric, NewRelic::Agent::Database.config,
-                                                                elapsed_time)
-              end
-            end
-          end
-        end
-
-      end
-    end
-  end
-end
-
-DependencyDetection.defer do
-  @name = :rails2_active_record
-  
-  depends_on do
-    defined?(ActiveRecord) && defined?(ActiveRecord::Base)
-  end
-
-  depends_on do
-    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 2
-  end
-
-  depends_on do
-    !NewRelic::Control.instance['skip_ar_instrumentation']
-  end
-
-  depends_on do
-    !NewRelic::Control.instance['disable_activerecord_instrumentation']
-  end
-  
-  executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 2 ActiveRecord instrumentation'
-  end
-  
-  executes do
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-      include ::NewRelic::Agent::Instrumentation::ActiveRecordInstrumentation
-    end
-  end
-
-  executes do
-    ActiveRecord::Base.class_eval do
-      NewRelic::Agent::Database::ConnectionManager.instance.config = connection.instance_eval{ @config }
-      class << self
-        add_method_tracer :find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql', :metric => false
-        add_method_tracer :transaction, 'ActiveRecord/#{self.name}/transaction', :metric => false
-      end
-    end
-  end
-end
-
-DependencyDetection.detect!

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

@@ -1,125 +0,0 @@
-module NewRelic
-  module Agent
-    module Instrumentation
-      module ActiveRecordInstrumentation
-
-        def self.included(instrumented_class)
-          instrumented_class.class_eval do
-            unless instrumented_class.method_defined?(:log_without_newrelic_instrumentation)
-              alias_method :log_without_newrelic_instrumentation, :log
-              alias_method :log, :log_with_newrelic_instrumentation
-              protected :log
-            end
-          end
-        end
-
-        def log_with_newrelic_instrumentation(*args, &block)
-
-          return log_without_newrelic_instrumentation(*args, &block) unless NewRelic::Agent.is_execution_traced?
-
-          sql, name, binds = args
-
-          if name && (parts = name.split " ") && parts.size == 2
-            model = parts.first
-            operation = parts.last.downcase
-            metric_name = case operation
-                          when 'load', 'count', 'exists' then 'find'
-                          when 'indexes', 'columns' then nil # fall back to DirectSQL
-                          when 'destroy', 'find', 'save', 'create' then operation
-                          when 'update' then 'save'
-                          else
-                            if model == 'Join'
-                              operation
-                            end
-                          end
-            metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
-          end
-
-          if metric.nil?
-            metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
-            if metric.nil?
-              if sql =~ /^(select|update|insert|delete|show)/i
-                # Could not determine the model/operation so let's find a better
-                # metric.  If it doesn't match the regex, it's probably a show
-                # command or some DDL which we'll ignore.
-                metric = "Database/SQL/#{$1.downcase}"
-              else
-                metric = "Database/SQL/other"
-              end
-            end
-          end
-
-          if !metric
-            log_without_newrelic_instrumentation(*args, &block)
-          else
-            metrics = [metric, "ActiveRecord/all"]
-            metrics << "ActiveRecord/#{metric_name}" if metric_name
-            if NewRelic::Agent::Database.config && NewRelic::Agent::Database.config[:adapter]
-              type = NewRelic::Agent::Database.config[:adapter].sub(/\d*/, '')
-              host = NewRelic::Agent::Database.config[:host] || 'localhost'
-              metrics << "RemoteService/sql/#{type}/#{host}"
-            end            
-            
-            self.class.trace_execution_scoped(metrics) do
-              sql, name, binds = args
-              t0 = Time.now
-              begin
-                log_without_newrelic_instrumentation(*args, &block)
-              ensure
-                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, NewRelic::Agent::Database.config,
-                                                                        (Time.now - t0).to_f)
-                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric, NewRelic::Agent::Database.config,
-                                                                (Time.now - t0).to_f)
-              end
-            end
-          end
-        end
-
-      end
-    end
-  end
-end
-
-DependencyDetection.defer do
-  @name = :rails3_active_record
-  
-  depends_on do
-    defined?(ActiveRecord) && defined?(ActiveRecord::Base)
-  end
-
-  depends_on do
-    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
-  end
-
-  depends_on do
-    !NewRelic::Control.instance['skip_ar_instrumentation']
-  end
-
-  depends_on do
-    !NewRelic::Control.instance['disable_activerecord_instrumentation']
-  end
-  
-  executes do
-    NewRelic::Agent.logger.debug 'Installing Rails 3 ActiveRecord instrumentation'
-  end
-  
-  executes do
-    Rails.configuration.after_initialize do
-      ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-        include ::NewRelic::Agent::Instrumentation::ActiveRecordInstrumentation
-      end
-    end
-  end
-
-  executes do
-    Rails.configuration.after_initialize do
-      ActiveRecord::Base.class_eval do
-        NewRelic::Agent::Database::ConnectionManager.instance.config = connection.instance_eval{ @config }
-        class << self
-          add_method_tracer :find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql', :metric => false
-          add_method_tracer :transaction, 'ActiveRecord/#{self.name}/transaction', :metric => false
-        end
-      end
-    end
-  end
-end