newrelic_rpm 8.15.0 → 9.6.0

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

@@ -5,7 +5,11 @@
 module NewRelic::Agent::Instrumentation
   module HTTPClient
     module Instrumentation
+      INSTRUMENTATION_NAME = 'HTTPClient'
+
       def with_tracing(request, connection)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         wrapped_request = NewRelic::Agent::HTTPClients::HTTPClientRequest.new(request)
         segment = NewRelic::Agent::Tracer.start_external_request_segment(
           library: wrapped_request.type,

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

@@ -4,7 +4,11 @@
 
 module NewRelic::Agent::Instrumentation
   module HTTPrb
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def with_tracing(request)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       wrapped_request = ::NewRelic::Agent::HTTPClients::HTTPRequest.new(request)
 
       begin

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

@@ -14,7 +14,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info("Installing http.rb Wrappers")
+    NewRelic::Agent.logger.info('Installing http.rb Wrappers')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/http_rb_wrappers'
   end

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

@@ -0,0 +1,20 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module HTTPX
+    module Chain
+      def self.instrument!
+        ::HTTPX::Session.class_eval do
+          include NewRelic::Agent::Instrumentation::HTTPX
+
+          alias_method(:send_requests_without_tracing, :send_requests)
+          def send_requests(*requests)
+            send_requests_with_tracing(*requests) { send_requests_without_tracing(*requests) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/http_clients/httpx_wrappers'
+
+module NewRelic::Agent::Instrumentation::HTTPX
+  INSTRUMENTATION_NAME = 'HTTPX'
+  NOTICEABLE_ERROR_CLASS = 'HTTPX::Error'
+
+  def send_requests_with_tracing(*requests)
+    NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+    requests.each { |r| nr_start_segment(r) }
+    yield
+  end
+
+  def nr_start_segment(request)
+    return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+    wrapped_request = NewRelic::Agent::HTTPClients::HTTPXHTTPRequest.new(request)
+    segment = NewRelic::Agent::Tracer.start_external_request_segment(
+      library: wrapped_request.type,
+      uri: wrapped_request.uri,
+      procedure: wrapped_request.method
+    )
+    segment.add_request_headers(wrapped_request)
+
+    request.on(:response) { nr_finish_segment.call(request, segment) }
+  end
+
+  def nr_finish_segment
+    proc do |request, segment|
+      response = @responses[request]
+
+      unless response
+        NewRelic::Agent.logger.debug('Processed an on-response callback for HTTPX but could not find the response!')
+        next
+      end
+
+      wrapped_response = NewRelic::Agent::HTTPClients::HTTPXHTTPResponse.new(response)
+      segment.process_response_headers(wrapped_response)
+
+      if response.is_a?(::HTTPX::ErrorResponse)
+        e = NewRelic::Agent::NoticeableError.new(NOTICEABLE_ERROR_CLASS, "Couldn't connect: #{response}")
+        segment.notice_error(e)
+      end
+
+      ::NewRelic::Agent::Transaction::Segment.finish(segment)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic::Agent::Instrumentation
+  module HTTPX
+    module Prepend
+      include NewRelic::Agent::Instrumentation::HTTPX
+
+      def send_requests(*requests)
+        send_requests_with_tracing(*requests) { super }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'httpx/chain'
+require_relative 'httpx/instrumentation'
+require_relative 'httpx/prepend'
+
+DependencyDetection.defer do
+  named :httpx
+
+  depends_on do
+    defined?(HTTPX) && Gem::Version.new(HTTPX::VERSION) >= Gem::Version.new('1.0.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing httpx instrumentation')
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument HTTPX::Session, NewRelic::Agent::Instrumentation::HTTPX::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::HTTPX::Chain
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module NewRelic
 
               only_actions.include?(action_name) || (!except_actions.empty? && !except_actions.include?(action_name))
             else
-              !!ignore_actions
+              !ignore_actions.nil?
             end
 
             return true if should_filter

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

@@ -6,6 +6,8 @@ module NewRelic
   module Agent
     module Instrumentation
       module Logger
+        INSTRUMENTATION_NAME = 'Logger'
+
         def skip_instrumenting?
           defined?(@skip_instrumenting) && @skip_instrumenting
         end
@@ -51,6 +53,7 @@ module NewRelic
             mark_skip_instrumenting
 
             unless ::NewRelic::Agent.agent.nil?
+              ::NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
               ::NewRelic::Agent.agent.log_event_aggregator.record(formatted_message, severity)
               formatted_message = LocalLogDecorator.decorate(formatted_message)
             end

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

@@ -15,7 +15,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info("Installing Logger instrumentation")
+    NewRelic::Agent.logger.info('Installing Logger instrumentation')
 
     if use_prepend?
       prepend_instrument Logger, NewRelic::Agent::Instrumentation::Logger::Prepend

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

@@ -58,7 +58,9 @@ module NewRelic
             end.class_eval do
               include NewRelic::Agent::Instrumentation::Memcache::Tracer
 
-              # TODO: Dalli - 3.1.0 renamed send_multiget to pipelined_get, but the method is otherwise the same
+              # TODO: MAJOR VERSION
+              # Dalli - 3.1.0 renamed send_multiget to pipelined_get, but the method is otherwise the same
+              # Once we no longer support Dalli < 3.1.0, remove this conditional logic
               if Gem::Version.new(::Dalli::VERSION) >= Gem::Version.new('3.1.0')
                 alias_method(:pipelined_get_without_newrelic_trace, :pipelined_get)
                 def pipelined_get(keys)

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

@@ -8,11 +8,14 @@ module NewRelic::Agent::Instrumentation
       SLASH = '/'
       UNKNOWN = 'unknown'
       LOCALHOST = 'localhost'
-      MULTIGET_METRIC_NAME = "get_multi_request"
-      MEMCACHED = "Memcached"
+      MULTIGET_METRIC_NAME = 'get_multi_request'
+      MEMCACHED = 'Memcached'
+      INSTRUMENTATION_NAME = 'Dalli'
 
       def with_newrelic_tracing(operation, *args)
-        segment = NewRelic::Agent::Tracer.start_datastore_segment( \
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        segment = NewRelic::Agent::Tracer.start_datastore_segment(
           product: MEMCACHED,
           operation: operation
         )
@@ -28,6 +31,8 @@ module NewRelic::Agent::Instrumentation
       end
 
       def server_for_key_with_newrelic_tracing
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         yield.tap do |server|
           begin
             if txn = ::NewRelic::Agent::Tracer.current_transaction
@@ -43,7 +48,9 @@ module NewRelic::Agent::Instrumentation
       end
 
       def get_multi_with_newrelic_tracing(method_name)
-        segment = NewRelic::Agent::Tracer.start_segment( \
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        segment = NewRelic::Agent::Tracer.start_segment(
           name: "Ruby/Memcached/Dalli/#{method_name}"
         )
 
@@ -55,7 +62,9 @@ module NewRelic::Agent::Instrumentation
       end
 
       def send_multiget_with_newrelic_tracing(keys)
-        segment = ::NewRelic::Agent::Tracer.start_datastore_segment( \
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        segment = ::NewRelic::Agent::Tracer.start_datastore_segment(
           product: MEMCACHED,
           operation: MULTIGET_METRIC_NAME
         )

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

@@ -84,7 +84,9 @@ module NewRelic::Agent::Instrumentation
           extend Helper
           include NewRelic::Agent::Instrumentation::Memcache::Tracer
 
-          # TODO: Dalli - 3.1.0 renamed send_multiget to pipelined_get, but the method is otherwise the same
+          # TODO: MAJOR VERSION
+          # Dalli - 3.1.0 renamed send_multiget to pipelined_get, but the method is otherwise the same
+          # Once we no longer support Dalli < 3.1.0, remove this conditional logic
           if Gem::Version.new(::Dalli::VERSION) >= Gem::Version.new('3.1.0')
             def pipelined_get(keys)
               send_multiget_with_newrelic_tracing(keys) { super }

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

@@ -5,8 +5,8 @@
 # NOTE: there are multiple implementations of the Memcached client in Ruby,
 # each with slightly different APIs and semantics.
 # See:
-#     http://www.deveiate.org/code/Ruby-MemCache/ (Gem: Ruby-MemCache)
-#     http://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
+#     https://rubygems.org/gems/Ruby-MemCache (Gem: Ruby-MemCache)
+#     https://github.com/mperham/memcache-client (Gem: memcache-client)
 #     https://github.com/mperham/dalli (Gem: dalli)
 
 require_relative 'memcache/helper'
@@ -23,9 +23,9 @@ DependencyDetection.defer do
   executes do
     if use_prepend?
       prepend_module = NewRelic::Agent::Instrumentation::Memcache::Prepend.client_prepender(MemCache)
-      prepend_instrument MemCache, prepend_module, "MemcacheClient"
+      prepend_instrument MemCache, prepend_module, 'MemcacheClient'
     else
-      chain_instrument_target MemCache, NewRelic::Agent::Instrumentation::Memcache::Chain, "MemcacheClient"
+      chain_instrument_target MemCache, NewRelic::Agent::Instrumentation::Memcache::Chain, 'MemcacheClient'
     end
   end
 end
@@ -38,15 +38,15 @@ DependencyDetection.defer do
   executes do
     if use_prepend?
       prepend_module = NewRelic::Agent::Instrumentation::Memcache::Prepend.client_prepender(Memcached)
-      prepend_instrument Memcached, prepend_module, "Memcached"
+      prepend_instrument Memcached, prepend_module, 'Memcached'
     else
-      chain_instrument_target Memcached, NewRelic::Agent::Instrumentation::Memcache::Chain, "Memcached"
+      chain_instrument_target Memcached, NewRelic::Agent::Instrumentation::Memcache::Chain, 'Memcached'
     end
   end
 end
 
 DependencyDetection.defer do
-  named :dalli
+  @name = :dalli
   configure_with :memcache
 
   depends_on { defined? Dalli::Client }
@@ -55,10 +55,10 @@ DependencyDetection.defer do
     if use_prepend?
       prepend_module = NewRelic::Agent::Instrumentation::Memcache::Prepend
       prepend_module.dalli_prependers do |client_class, instrumenting_module|
-        prepend_instrument client_class, instrumenting_module, "MemcachedDalli"
+        prepend_instrument client_class, instrumenting_module, 'MemcachedDalli'
       end
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Memcache::Dalli
+      chain_instrument NewRelic::Agent::Instrumentation::Memcache::Dalli, 'MemcachedDalli'
     end
   end
 end
@@ -67,7 +67,7 @@ end
 # dalli/cas/client. Use a separate dependency block so it can potentially
 # re-evaluate after they've done that require.
 DependencyDetection.defer do
-  named :dalli_cas_client
+  @name = :dalli_cas_client
   configure_with :memcache
 
   depends_on { defined? Dalli::Client }
@@ -78,10 +78,10 @@ DependencyDetection.defer do
     if use_prepend?
       prepend_module = NewRelic::Agent::Instrumentation::Memcache::Prepend
       prepend_module.dalli_cas_prependers do |client_class, instrumenting_module|
-        prepend_instrument client_class, instrumenting_module, "MemcachedDalliCAS"
+        prepend_instrument client_class, instrumenting_module, 'MemcachedDalliCAS'
       end
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Memcache::DalliCAS
+      chain_instrument NewRelic::Agent::Instrumentation::Memcache::DalliCAS, 'MemcachedDalliCAS'
     end
   end
 end

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

@@ -15,8 +15,8 @@ module NewRelic
       class MiddlewareProxy
         include MiddlewareTracing
 
-        ANONYMOUS_CLASS = "AnonymousClass".freeze
-        OBJECT_CLASS_NAME = "Object".freeze
+        ANONYMOUS_CLASS = 'AnonymousClass'.freeze
+        OBJECT_CLASS_NAME = 'Object'.freeze
 
         # This class is used to wrap classes that are passed to
         # Rack::Builder#use without synchronously instantiating those classes.
@@ -92,7 +92,7 @@ module NewRelic
           clazz = class_for_target
 
           name = clazz.name
-          name = clazz.superclass.name if name.nil? || name == ""
+          name = clazz.superclass.name if name.nil? || name == ''
           name = ANONYMOUS_CLASS if name.nil? || name == OBJECT_CLASS_NAME
           name
         end

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

@@ -108,7 +108,7 @@ module NewRelic
             NewRelic::Agent.notice_error(e)
             raise e
           ensure
-            finishable.finish if finishable
+            finishable&.finish
           end
         end
 

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

@@ -9,7 +9,7 @@ module NewRelic
     module Instrumentation
       class MongodbCommandSubscriber
         MONGODB = 'MongoDB'.freeze
-        COLLECTION = "collection".freeze
+        COLLECTION = 'collection'.freeze
 
         def started(event)
           begin
@@ -21,7 +21,7 @@ module NewRelic
           end
         end
 
-        ERROR_KEYS = %w[ writeErrors writeConcernError writeConcernErrors ].freeze
+        ERROR_KEYS = %w[writeErrors writeConcernError writeConcernErrors].freeze
 
         def error_key_present?(event)
           if reply = event.reply
@@ -43,7 +43,7 @@ module NewRelic
             if error_key = error_key_present?(event)
               # taking the last error as there can potentially be many
               attributes = event.reply[error_key][-1]
-              segment.notice_error(Mongo::Error.new("%s (%s)" % [attributes["errmsg"], attributes["code"]]))
+              segment.notice_error(Mongo::Error.new('%s (%s)' % [attributes['errmsg'], attributes['code']]))
 
             # failing commands return a CommandFailed event with an error message
             # in the form of "% (%s)" for the message and code
@@ -106,8 +106,8 @@ module NewRelic
           )
         end
 
-        UNKNOWN = "unknown".freeze
-        LOCALHOST = "localhost".freeze
+        UNKNOWN = 'unknown'.freeze
+        LOCALHOST = 'localhost'.freeze
 
         def host_from_address(address)
           if unix_domain_socket?(address.host)
@@ -131,10 +131,8 @@ module NewRelic
           UNKNOWN
         end
 
-        SLASH = "/".freeze
-
         def unix_domain_socket?(host)
-          host.start_with?(SLASH)
+          host.start_with?(NewRelic::SLASH)
         end
       end
     end

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

@@ -6,7 +6,11 @@ module NewRelic
   module Agent
     module Instrumentation
       module NetHTTP
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
         def request_with_tracing(request)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
 
           segment = NewRelic::Agent::Tracer.start_external_request_segment(
@@ -31,7 +35,7 @@ module NewRelic
             segment.process_response_headers(wrapped_response)
             response
           ensure
-            segment.finish
+            segment&.finish
           end
         end
       end

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

@@ -27,11 +27,11 @@ DependencyDetection.defer do
   end
 
   conflicts_with_prepend do
-    defined?(Rack::MiniProfiler)
+    defined?(Rack::MiniProfiler) && !defined?(Rack::MINI_PROFILER_PREPEND_NET_HTTP_PATCH)
   end
 
   conflicts_with_prepend do
-    source_location_for(Net::HTTP, "request") =~ /airbrake|profiler/i
+    source_location_for(Net::HTTP, 'request') =~ /airbrake|profiler/i
   end
 
   executes do

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

@@ -47,6 +47,51 @@ module NewRelic
           end
         end
 
+        # The agent doesn't use the traditional ActiveSupport::Notifications.subscribe
+        # pattern due to threading issues discovered on initial instrumentation.
+        # Instead we define a #start and #finish method, which Rails responds to.
+        # See: https://github.com/rails/rails/issues/12069
+        def start(name, id, payload)
+          return unless state.is_execution_traced?
+
+          start_segment(name, id, payload)
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload)
+          return unless state.is_execution_traced?
+
+          finish_segment(id, payload)
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def start_segment(name, id, payload)
+          segment = Tracer.start_segment(name: metric_name(name, payload))
+          add_segment_params(segment, payload)
+          push_segment(id, segment)
+        end
+
+        def finish_segment(id, payload)
+          if segment = pop_segment(id)
+            if exception = exception_object(payload)
+              segment.notice_error(exception)
+            end
+            segment.finish
+          end
+        end
+
+        # for subclasses
+        def add_segment_params(segment, payload)
+          # no op
+        end
+
+        # for subclasses
+        def metric_name(name, payload)
+          "Ruby/#{name}"
+        end
+
         def log_notification_error(error, name, event_type)
           # These are important enough failures that we want the backtraces
           # logged at error level, hence the explicit log_exception call.
@@ -77,7 +122,7 @@ module NewRelic
           return if defined?(exception_object)
           return unless defined?(::ActiveSupport::VERSION)
 
-          if ::ActiveSupport::VERSION::STRING < "5.0.0"
+          if ::ActiveSupport::VERSION::STRING < '5.0.0'
             # Earlier versions of Rails did not add the exception itself to the
             # payload accessible via :exception_object, so we create a stand-in
             # error object from the given class name and message.

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

@@ -4,11 +4,15 @@
 
 module NewRelic::Agent::Instrumentation
   module Padrino
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def invoke_route_with_tracing(*args)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       begin
-        env["newrelic.last_route"] = args[0].original_path
+        env['newrelic.last_route'] = args[0].original_path
       rescue => e
-        ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
+        ::NewRelic::Agent.logger.debug('Failed determining last route in Padrino', e)
       end
 
       begin
@@ -19,7 +23,7 @@ module NewRelic::Agent::Instrumentation
           )
         end
       rescue => e
-        ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
+        ::NewRelic::Agent.logger.debug('Failed during invoke_route to set transaction name', e)
       end
 
       yield

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

@@ -10,10 +10,10 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.debug("Installing Passenger event hooks.")
+    NewRelic::Agent.logger.debug('Installing Passenger event hooks.')
 
     PhusionPassenger.on_event(:stopping_worker_process) do
-      NewRelic::Agent.logger.debug("Passenger stopping this process, shutdown the agent.")
+      NewRelic::Agent.logger.debug('Passenger stopping this process, shutdown the agent.')
       NewRelic::Agent.instance.shutdown
     end
 

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

@@ -5,7 +5,7 @@
 module NewRelic
   module Agent
     module Instrumentation
-      # https://newrelic.com/docs/features/tracking-front-end-time
+      # https://docs.newrelic.com/docs/features/tracking-front-end-time
       # Record queue time metrics based on any of three headers
       # which can be set on the request.
       module QueueTime

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

@@ -6,6 +6,8 @@ module NewRelic
   module Agent
     module Instrumentation
       module RackBuilder
+        INSTRUMENTATION_NAME = 'Rack'
+
         def self.track_deferred_detection(builder_class)
           class << builder_class
             attr_accessor :_nr_deferred_detection_ran
@@ -16,7 +18,7 @@ module NewRelic
         def deferred_dependency_check
           return if self.class._nr_deferred_detection_ran
 
-          NewRelic::Agent.logger.info("Doing deferred dependency-detection before Rack startup")
+          NewRelic::Agent.logger.info('Doing deferred dependency-detection before Rack startup')
           DependencyDetection.detect!
           self.class._nr_deferred_detection_ran = true
         end
@@ -51,6 +53,8 @@ module NewRelic
         def run_with_tracing(app)
           return yield(app) unless middleware_instrumentation_enabled?
 
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true))
         end
 
@@ -58,6 +62,8 @@ module NewRelic
           return if middleware_class.nil?
           return yield(middleware_class) unless middleware_instrumentation_enabled?
 
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           yield(::NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class))
         end
       end

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

@@ -9,6 +9,8 @@ module NewRelic
     module Instrumentation
       module Rails3
         module ActionController
+          INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
           # determine the path that is used in the metric name for
           # the called controller action
           def newrelic_metric_path(action_name_override = nil)
@@ -21,6 +23,8 @@ module NewRelic
           end
 
           def process_action(*args) # THREAD_LOCAL_ACCESS
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             munged_params = NewRelic::Agent::ParameterFiltering.filter_rails_request_parameters(request.filtered_parameters)
             perform_action_with_newrelic_trace(:category => :controller,
               :name => self.action_name,
@@ -37,7 +41,7 @@ module NewRelic
             extend self
             def template_metric(identifier, options = {})
               if options[:file]
-                "file"
+                'file'
               elsif identifier.nil?
                 ::NewRelic::Agent::UNKNOWN_METRIC
               elsif identifier.include?('/') # this is a filepath
@@ -112,7 +116,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, true)
-        identifier = determine_template(options) ? determine_template(options).identifier : nil
+        # this file can't be found in SimpleCov, need to check test coverage
+        identifier = determine_template(options) ? determine_template(options).identifier : nil # rubocop:disable Style/SafeNavigation
         scope_name = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier, options)}/Rendering"
         trace_execution_scoped(scope_name) do
           render_without_newrelic(context, options)

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

@@ -16,7 +16,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info("Installing Rails 3+ middleware instrumentation")
+    NewRelic::Agent.logger.info('Installing Rails 3+ middleware instrumentation')
     module ActionDispatch
       class MiddlewareStack
         class Middleware