newrelic_rpm 6.15.0 → 8.0.0

data/lib/new_relic/agent/instrumentation/padrino/prepend.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic::Agent::Instrumentation
+  module Padrino
+    module Prepend
+      include NewRelic::Agent::Instrumentation::Sinatra
+      include NewRelic::Agent::Instrumentation::Padrino
+
+      def dispatch
+        dispatch_with_tracing { super }
+      end
+
+      def invoke_route(*args, &block)
+        invoke_route_with_tracing(*args) { super }
+      end
+    end
+  end
+end

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

@@ -2,69 +2,34 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
-require 'new_relic/agent/instrumentation/sinatra'
+# Our Padrino instrumentation relies heavily on the fact that Padrino is
+# built on Sinatra. Although it wires up a lot of its own routing logic,
+# we only need to patch into Padrino's dispatch to get things started.
+#
+# Parts of the Sinatra instrumentation (such as the TransactionNamer) are
+# aware of Padrino as a potential target in areas where both Sinatra and
+# Padrino run through the same code.
+
+require_relative 'sinatra'
+require_relative 'padrino/chain'
+require_relative 'padrino/instrumentation'
+require_relative 'padrino/prepend'
 
 DependencyDetection.defer do
   @name = :padrino
+  configure_with :sinatra
 
-  depends_on do
-    !NewRelic::Agent.config[:disable_sinatra] &&
-      defined?(::Padrino) && defined?(::Padrino::Routing::InstanceMethods)
-  end
+  depends_on { defined?(::Padrino) && defined?(::Padrino::Routing::InstanceMethods) }
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Padrino instrumentation'
-
-    # Our Padrino instrumentation relies heavily on the fact that Padrino is
-    # built on Sinatra. Although it wires up a lot of its own routing logic,
-    # we only need to patch into Padrino's dispatch to get things started.
-    #
-    # Parts of the Sinatra instrumentation (such as the TransactionNamer) are
-    # aware of Padrino as a potential target in areas where both Sinatra and
-    # Padrino run through the same code.
-    module ::Padrino::Routing::InstanceMethods
-      include NewRelic::Agent::Instrumentation::Sinatra
-
-      alias dispatch_without_newrelic dispatch!
-      alias dispatch! dispatch_with_newrelic
-
-      # Padrino 0.13 mustermann routing
-      if private_method_defined?(:invoke_route)
-        include NewRelic::Agent::Instrumentation::Padrino
-
-        alias invoke_route_without_newrelic invoke_route
-        alias invoke_route invoke_route_with_newrelic
-      end
+    if use_prepend?
+      prepend_instrument ::Padrino::Routing::InstanceMethods, NewRelic::Agent::Instrumentation::Padrino::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Padrino::Chain
     end
   end
 end
 
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Padrino
 
-        def invoke_route_with_newrelic(*args, &block)
-          begin
-            env["newrelic.last_route"] = args[0].original_path
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
-          end
 
-          begin
-            txn_name = ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name_for_route(env, request)
-            unless txn_name.nil?
-              ::NewRelic::Agent::Transaction.set_default_transaction_name(
-                "#{self.class.name}/#{txn_name}", :sinatra)
-            end
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
-          end
-
-          invoke_route_without_newrelic(*args, &block)
-        end
-
-      end
-    end
-  end
-end

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

@@ -15,7 +15,7 @@ module NewRelic
         ALL_QUEUE_METRIC        = 'WebFrontend/QueueTime'.freeze
         # any timestamps before this are thrown out and the parser
         # will try again with a larger unit (2000/1/1 UTC)
-        EARLIEST_ACCEPTABLE_TIME = Time.at(946684800)
+        EARLIEST_ACCEPTABLE_TIME = Time.at(946684800).to_f
 
         CANDIDATE_HEADERS = [
           REQUEST_START_HEADER,
@@ -27,7 +27,7 @@ module NewRelic
 
         module_function
 
-        def parse_frontend_timestamp(headers, now=Time.now)
+        def parse_frontend_timestamp(headers, now=Process.clock_gettime(Process::CLOCK_REALTIME))
           earliest = nil
 
           CANDIDATE_HEADERS.each do |header|
@@ -40,7 +40,7 @@ module NewRelic
           end
 
           if earliest && earliest > now
-            NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now.to_f}")
+            NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now}")
             earliest = now
           end
 
@@ -59,7 +59,7 @@ module NewRelic
         def parse_timestamp(string)
           DIVISORS.each do |divisor|
             begin
-              t = Time.at(string.to_f / divisor)
+              t = (string.to_f / divisor)
               return t if t > EARLIEST_ACCEPTABLE_TIME
             rescue RangeError
               # On Ruby versions built with a 32-bit time_t, attempting to

data/lib/new_relic/agent/instrumentation/rack/chain.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic::Agent::Instrumentation
+  module Rack
+    module Chain
+      def self.instrument! builder_class
+        NewRelic::Agent::Instrumentation::RackBuilder.track_deferred_detection builder_class
+
+        builder_class.class_eval do
+          include ::NewRelic::Agent::Instrumentation::RackBuilder
+  
+          def to_app_with_newrelic_deferred_dependency_detection
+            with_deferred_dependency_detection { to_app_without_newrelic }
+          end
+
+          alias_method :to_app_without_newrelic, :to_app
+          alias_method :to_app, :to_app_with_newrelic_deferred_dependency_detection
+  
+          if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+            ::NewRelic::Agent.logger.info "Installing #{builder_class} middleware instrumentation"
+
+            def run_with_newrelic(app, *args)
+              run_with_tracing(app) { |wrapped_app| run_without_newrelic(wrapped_app, *args) }
+            end
+   
+            alias_method :run_without_newrelic, :run
+            alias_method :run, :run_with_newrelic
+  
+            def use_with_newrelic(middleware_class, *args, &block)
+              use_with_tracing(middleware_class) { |wrapped_class| use_without_newrelic(wrapped_class, *args, &block) }
+            end
+            ruby2_keywords(:use_with_newrelic) if respond_to?(:ruby2_keywords, true)
+
+            alias_method :use_without_newrelic, :use
+            alias_method :use, :use_with_newrelic
+          end
+        end
+      end
+    end
+
+    module URLMap
+      module Chain
+        def self.instrument! url_map_class
+          url_map_class.class_eval do
+            alias_method :initialize_without_newrelic, :initialize
+    
+            def initialize(map = {})
+              traced_map = ::NewRelic::Agent::Instrumentation::RackURLMap.generate_traced_map(map)
+              initialize_without_newrelic(traced_map)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rack/helpers.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic::Agent::Instrumentation
+  module RackHelpers
+    def self.version_supported?
+      rack_version_supported? || puma_rack_version_supported?
+    end
+
+    def self.rack_version_supported?
+      return false unless defined? ::Rack
+
+      version = Gem::Version.new(::Rack.release)
+      min_version = Gem::Version.new('1.1.0')
+      version >= min_version
+    end
+
+    def self.puma_rack_version_supported?
+      return false unless defined? ::Puma::Const::PUMA_VERSION
+
+      version = Gem::Version.new(::Puma::Const::PUMA_VERSION)
+      min_version = Gem::Version.new('2.12.0')
+      version >= min_version
+    end
+
+    def self.middleware_instrumentation_enabled?
+      version_supported? && !::NewRelic::Agent.config[:disable_middleware_instrumentation]
+    end
+  end
+end
+

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module RackBuilder
+
+        def self.track_deferred_detection builder_class
+          class << builder_class
+            attr_accessor :_nr_deferred_detection_ran
+          end
+          builder_class._nr_deferred_detection_ran = false
+        end
+
+        def deferred_dependency_check
+          return if self.class._nr_deferred_detection_ran
+  
+          NewRelic::Agent.logger.info "Doing deferred dependency-detection before Rack startup"
+          DependencyDetection.detect!
+          self.class._nr_deferred_detection_ran = true
+        end
+
+        def check_for_late_instrumentation(app)
+          return if defined?(@checked_for_late_instrumentation) && @checked_for_late_instrumentation
+          @checked_for_late_instrumentation = true
+          if middleware_instrumentation_enabled?
+            if ::NewRelic::Agent::Instrumentation::MiddlewareProxy.needs_wrapping?(app)
+              ::NewRelic::Agent.logger.info("We weren't able to instrument all of your Rack middlewares.",
+                                            "To correct this, ensure you 'require \"newrelic_rpm\"' before setting up your middleware stack.")
+            end
+          end
+        end
+
+        # We patch the #to_app method for a reason that actually has nothing to do with
+        # instrumenting rack itself. It happens to be a convenient and
+        # easy-to-hook point that happens late in the startup sequence of almost
+        # every application, making it a good place to do a final call to
+        # DependencyDetection.detect!, since all libraries are likely loaded at
+        # this point.
+        def with_deferred_dependency_detection
+          deferred_dependency_check
+          yield.tap{ |result| check_for_late_instrumentation(result) }
+        end
+
+        def middleware_instrumentation_enabled?
+          ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+        end
+
+        def run_with_tracing app
+          return yield(app) unless middleware_instrumentation_enabled?
+          yield ::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+        end
+
+        def use_with_tracing middleware_class
+          return if middleware_class.nil?
+          return yield(middleware_class) unless middleware_instrumentation_enabled?
+          yield ::NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+        end
+      end
+
+      module RackURLMap
+        def self.generate_traced_map(map)
+          map.inject({}) do |traced_map, (url, handler)|
+            traced_map[url] = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(handler, true)
+            traced_map
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rack/prepend.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic::Agent::Instrumentation
+  module Rack
+    
+    module URLMap
+      module Prepend
+        def initialize(map = {})
+          super ::NewRelic::Agent::Instrumentation::RackURLMap.generate_traced_map(map)
+        end
+      end
+    end
+
+    module Prepend
+      include ::NewRelic::Agent::Instrumentation::RackBuilder
+
+      def self.prepended builder_class
+        NewRelic::Agent::Instrumentation::RackBuilder.track_deferred_detection builder_class
+      end
+
+      def to_app
+        with_deferred_dependency_detection { super }
+      end
+
+      def run(app, *args)
+        run_with_tracing(app) { |wrapped_app| super(wrapped_app, *args) }
+      end
+
+      def use(middleware_class, *args, &blk)
+        use_with_tracing(middleware_class) { |wrapped_class| super(wrapped_class, *args, &blk) }
+      end
+      ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
+    end
+  end
+end

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

@@ -4,134 +4,10 @@
 
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
-module NewRelic
-  module Agent
-    module Instrumentation
-      module RackHelpers
-        def self.version_supported?
-          rack_version_supported? || puma_rack_version_supported?
-        end
-
-        def self.rack_version_supported?
-          return false unless defined? ::Rack
-
-          version = Gem::Version.new(::Rack.release)
-          min_version = Gem::Version.new('1.1.0')
-          version >= min_version
-        end
-
-        def self.puma_rack_version_supported?
-          return false unless defined? ::Puma::Const::PUMA_VERSION
-
-          version = Gem::Version.new(::Puma::Const::PUMA_VERSION)
-          min_version = Gem::Version.new('2.12.0')
-          version >= min_version
-        end
-
-        def self.middleware_instrumentation_enabled?
-          version_supported? && !::NewRelic::Agent.config[:disable_middleware_instrumentation]
-        end
-
-        def self.check_for_late_instrumentation(app)
-          return if defined?(@checked_for_late_instrumentation) && @checked_for_late_instrumentation
-          @checked_for_late_instrumentation = true
-          if middleware_instrumentation_enabled?
-            if ::NewRelic::Agent::Instrumentation::MiddlewareProxy.needs_wrapping?(app)
-              ::NewRelic::Agent.logger.info("We weren't able to instrument all of your Rack middlewares.",
-                                            "To correct this, ensure you 'require \"newrelic_rpm\"' before setting up your middleware stack.")
-            end
-          end
-        end
-
-        def self.instrument_builder builder_class
-          ::NewRelic::Agent.logger.info "Installing deferred #{builder_class} instrumentation"
-
-          builder_class.class_eval do
-            class << self
-              attr_accessor :_nr_deferred_detection_ran
-            end
-            self._nr_deferred_detection_ran = false
-
-            include ::NewRelic::Agent::Instrumentation::RackBuilder
-
-            alias_method :to_app_without_newrelic, :to_app
-            alias_method :to_app, :to_app_with_newrelic_deferred_dependency_detection
-
-            if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
-              ::NewRelic::Agent.logger.info "Installing #{builder_class} middleware instrumentation"
-              alias_method :run_without_newrelic, :run
-              alias_method :run, :run_with_newrelic
-
-              alias_method :use_without_newrelic, :use
-              alias_method :use, :use_with_newrelic
-            end
-          end
-
-          def self.instrument_url_map url_map_class
-            url_map_class.class_eval do
-              alias_method :initialize_without_newrelic, :initialize
-
-              def initialize(map = {})
-                traced_map = ::NewRelic::Agent::Instrumentation::RackURLMap.generate_traced_map(map)
-                initialize_without_newrelic(traced_map)
-              end
-            end
-          end
-        end
-      end
-
-      module RackBuilder
-
-        def run_with_newrelic(app, *args)
-          if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
-            wrapped_app = ::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-            run_without_newrelic(wrapped_app, *args)
-          else
-            run_without_newrelic(app, *args)
-          end
-        end
-
-        def use_with_newrelic(middleware_class, *args, &blk)
-          return if middleware_class.nil?
-          if ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
-            wrapped_middleware_class = ::NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
-            use_without_newrelic(wrapped_middleware_class, *args, &blk)
-          else
-            use_without_newrelic(middleware_class, *args, &blk)
-          end
-        end
-
-        # We patch this method for a reason that actually has nothing to do with
-        # instrumenting rack itself. It happens to be a convenient and
-        # easy-to-hook point that happens late in the startup sequence of almost
-        # every application, making it a good place to do a final call to
-        # DependencyDetection.detect!, since all libraries are likely loaded at
-        # this point.
-        def to_app_with_newrelic_deferred_dependency_detection
-          unless self.class._nr_deferred_detection_ran
-            NewRelic::Agent.logger.info "Doing deferred dependency-detection before Rack startup"
-            DependencyDetection.detect!
-            self.class._nr_deferred_detection_ran = true
-          end
-
-          result = to_app_without_newrelic
-          ::NewRelic::Agent::Instrumentation::RackHelpers.check_for_late_instrumentation(result)
-
-          result
-        end
-      end
-
-      module RackURLMap
-        def self.generate_traced_map(map)
-          map.inject({}) do |traced_map, (url, handler)|
-            traced_map[url] = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(handler, true)
-            traced_map
-          end
-        end
-      end
-    end
-  end
-end
+require_relative 'rack/helpers'
+require_relative 'rack/instrumentation'
+require_relative 'rack/chain'
+require_relative 'rack/prepend'
 
 DependencyDetection.defer do
   named :rack
@@ -141,20 +17,27 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_builder ::Rack::Builder
+    if use_prepend?
+      prepend_instrument ::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Prepend
+    else
+      chain_instrument_target ::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Chain
+    end
   end
 end
 
-
 DependencyDetection.defer do
   named :puma_rack
 
   depends_on do
-    defined?(::Puma::Rack::Builder) && !NewRelic::Agent.config[:disable_puma_rack]
+    defined?(::Puma::Rack::Builder)
   end
 
   executes do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_builder ::Puma::Rack::Builder
+    if use_prepend?
+      prepend_instrument ::Puma::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Prepend
+    else
+      chain_instrument_target ::Puma::Rack::Builder, NewRelic::Agent::Instrumentation::Rack::Chain
+    end
   end
 end
 
@@ -166,12 +49,16 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled? &&
-      !::NewRelic::Agent.config[:disable_rack]
+    ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
   end
 
   executes do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_url_map ::Rack::URLMap
+    if use_prepend?
+      prepend_instrument ::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Prepend
+    else
+      chain_instrument_target ::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Chain
+      ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_url_map 
+    end
   end
 end
 
@@ -179,15 +66,18 @@ DependencyDetection.defer do
   named :puma_rack_urlmap
 
   depends_on do
-    defined? Puma::Rack::URLMap
+    defined?(Puma::Rack::URLMap)
   end
 
   depends_on do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled? &&
-      !::NewRelic::Agent.config[:disable_puma_rack]
+    ::NewRelic::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
   end
 
   executes do
-    ::NewRelic::Agent::Instrumentation::RackHelpers.instrument_url_map ::Puma::Rack::URLMap
+    if use_prepend?
+      prepend_instrument ::Puma::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Prepend
+    else
+      chain_instrument_target ::Puma::Rack::URLMap, NewRelic::Agent::Instrumentation::Rack::URLMap::Chain
+    end
   end
 end

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

@@ -20,13 +20,13 @@ DependencyDetection.defer do
   executes do
     ActionView::PartialTemplate.class_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render, 'View/#{path_without_extension[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Partial'
+      add_method_tracer :render, -> (*) { "View/#{path_without_extension[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Partial" }
     end
 
     # this is for template rendering, as opposed to partial rendering.
     ActionView::Template.class_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render, 'View/#{(path_without_extension || @view.controller.newrelic_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering'
+      add_method_tracer :render, -> (*) { "View/#{(path_without_extension || @view.controller.newrelic_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering" }
     end
   end
 end
@@ -47,7 +47,7 @@ DependencyDetection.defer do
   executes do
     ActionController::Base.class_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
+      add_method_tracer :render, -> (*) { "View/#{newrelic_metric_path}/Rendering" }
     end
   end
 end
@@ -68,12 +68,12 @@ DependencyDetection.defer do
   executes do
     ActionView::RenderablePartial.module_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render_partial, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial'
+      add_method_tracer :render_partial, -> (*) { "View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial" }
     end
 
     ActionView::Template.class_eval do
       include NewRelic::Agent::MethodTracer
-      add_method_tracer :render, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering'
+      add_method_tracer :render, -> (*) { "View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering" }
     end
   end
 end

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

@@ -38,7 +38,7 @@ DependencyDetection.defer do
     if defined?(ActionController) && defined?(ActionController::Base)
       ActionController::Base.class_eval do
         if method_defined? :perform_invocation
-          add_method_tracer :perform_invocation, 'WebService/#{controller_name}/#{args.first}'
+          add_method_tracer :perform_invocation, -> (*args) { "WebService/#{controller_name}/#{args.first}" }
         end
       end
     end

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

@@ -84,52 +84,16 @@ DependencyDetection.defer do
     end
   end
 end
-DependencyDetection.defer do
-  @name = :rails30_view
-
-  depends_on do
-    defined?(::Rails::VERSION::MAJOR) && defined?(::Rails::VERSION::MINOR) &&
-      ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails::VERSION::MINOR.to_i == 0
-  end
-
-  depends_on do
-    !NewRelic::Agent.config[:disable_view_instrumentation]
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 3.0 view instrumentation'
-  end
-
-  executes do
-    ActionView::Template.class_eval do
-      include NewRelic::Agent::MethodTracer
-      def render_with_newrelic(*args, &block)
-        options = if @virtual_path && @virtual_path.starts_with?('/') # file render
-          {:file => true }
-        else
-          {}
-        end
-        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(@identifier, options)}/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.render_type(@identifier)}"
-        trace_execution_scoped str do
-          render_without_newrelic(*args, &block)
-        end
-      end
-
-      alias_method :render_without_newrelic, :render
-      alias_method :render, :render_with_newrelic
-
-    end
-  end
-end
 
+# Though this uses the name :rails31_view, it is used only for rails 3.2 now
+# Rails 3.1 is no longer supported by the agent.
 DependencyDetection.defer do
   @name = :rails31_view
 
-  # We can't be sure that this will work with future versions of Rails 3.
-  # Currently enabled for Rails 3.1 and 3.2
+  # Enabled for Rails 3.2
   depends_on do
     defined?(::Rails::VERSION::MAJOR) && defined?(::Rails::VERSION::MINOR) &&
-      ::Rails::VERSION::MAJOR.to_i == 3 && ([1,2].member?(::Rails::VERSION::MINOR.to_i))
+      ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails::VERSION::MINOR.to_i == 2
   end
 
   depends_on do
@@ -137,7 +101,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Rails 3.1/3.2 view instrumentation'
+    ::NewRelic::Agent.logger.info 'Installing Rails 3.2 view instrumentation'
   end
 
   executes do