newrelic_rpm 9.3.0 → 9.6.0

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

@@ -0,0 +1,105 @@
+# 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/ethon_wrappers'
+
+module NewRelic::Agent::Instrumentation
+  module Ethon
+    module NRShared
+      INSTRUMENTATION_NAME = 'Ethon'
+      NOTICEABLE_ERROR_CLASS = 'Ethon::Errors::EthonError'
+
+      def prep_easy(easy, parent = nil)
+        wrapped_request = NewRelic::Agent::HTTPClients::EthonHTTPRequest.new(easy)
+        segment = NewRelic::Agent::Tracer.start_external_request_segment(
+          library: wrapped_request.type,
+          uri: wrapped_request.uri,
+          procedure: wrapped_request.method,
+          parent: parent
+        )
+        segment.add_request_headers(wrapped_request)
+
+        callback = proc do
+          wrapped_response = NewRelic::Agent::HTTPClients::EthonHTTPResponse.new(easy)
+          segment.process_response_headers(wrapped_response)
+
+          if easy.return_code != :ok
+            e = NewRelic::Agent::NoticeableError.new(NOTICEABLE_ERROR_CLASS,
+              "return_code: >>#{easy.return_code}<<, response_code: >>#{easy.response_code}<<")
+            segment.notice_error(e)
+          end
+
+          ::NewRelic::Agent::Transaction::Segment.finish(segment)
+        end
+
+        easy.on_complete { callback.call }
+
+        segment
+      end
+
+      def wrap_with_tracing(segment, &block)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        NewRelic::Agent::Tracer.capture_segment_error(segment) do
+          yield
+        end
+      ensure
+        NewRelic::Agent::Transaction::Segment.finish(segment)
+      end
+    end
+
+    module Easy
+      include NRShared
+
+      ACTION_INSTANCE_VAR = :@nr_action
+      HEADERS_INSTANCE_VAR = :@nr_headers
+
+      # `Ethon::Easy` doesn't expose the "action name" ('GET', 'POST', etc.)
+      # and Ethon's fabrication of HTTP classes uses
+      # `Ethon::Easy::Http::Custom` for non-standard actions. To be able to
+      # know the action name at `#perform` time, we set a new instance variable
+      # on the `Ethon::Easy` instance with the base name of the fabricated
+      # class, respecting the 'Custom' name where appropriate.
+      def fabricate_with_tracing(_url, action_name, _options)
+        fabbed = yield
+        instance_variable_set(ACTION_INSTANCE_VAR, NewRelic::Agent.base_name(fabbed.class.name).upcase)
+        fabbed
+      end
+
+      # `Ethon::Easy` uses `Ethon::Easy::Header` to set request headers on
+      # libcurl with `#headers=`. After they are set, they aren't easy to get
+      # at again except via FFI so set a new instance variable on the
+      # `Ethon::Easy` instance to store them in Ruby hash format.
+      def headers_equals_with_tracing(headers)
+        instance_variable_set(HEADERS_INSTANCE_VAR, headers)
+        yield
+      end
+
+      def perform_with_tracing(*args)
+        return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+        segment = prep_easy(self)
+        wrap_with_tracing(segment) { yield }
+      end
+    end
+
+    module Multi
+      include NRShared
+
+      MULTI_SEGMENT_NAME = 'External/Multiple/Ethon::Multi/perform'
+
+      def perform_with_tracing(*args)
+        return unless NewRelic::Agent::Tracer.state.is_execution_traced?
+
+        segment = NewRelic::Agent::Tracer.start_segment(name: MULTI_SEGMENT_NAME)
+
+        wrap_with_tracing(segment) do
+          easy_handles.each { |easy| prep_easy(easy, segment) }
+
+          yield
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# 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 Ethon
+    module Easy
+      module Prepend
+        include NewRelic::Agent::Instrumentation::Ethon::Easy
+
+        def fabricate(url, action_name, options)
+          fabricate_with_tracing(url, action_name, options) { super }
+        end
+
+        def headers=(headers)
+          headers_equals_with_tracing(headers) { super }
+        end
+
+        def perform(*args)
+          perform_with_tracing(*args) { super }
+        end
+      end
+    end
+
+    module Multi
+      module Prepend
+        include NewRelic::Agent::Instrumentation::Ethon::Multi
+
+        def perform(*args)
+          perform_with_tracing(*args) { super }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# 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 'ethon/instrumentation'
+require_relative 'ethon/chain'
+require_relative 'ethon/prepend'
+
+DependencyDetection.defer do
+  named :ethon
+
+  # If Ethon is being used as a dependency of Typhoeus, allow the Typhoeus
+  # instrumentation to handle everything. Otherwise each external network call
+  # will confusingly result in "Ethon" segments duplicating the information
+  # already provided by "Typhoeus" segments.
+  depends_on do
+    !defined?(Typhoeus)
+  end
+
+  depends_on do
+    defined?(Ethon) && Gem::Version.new(Ethon::VERSION) >= Gem::Version.new('0.12.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing ethon instrumentation')
+  end
+
+  executes do
+    if use_prepend?
+      # NOTE: by default prepend_instrument will go with the module name that
+      #       precedes 'Prepend' (so 'Easy' and 'Multi'), but we want to use
+      #       'Ethon::Easy' and 'Ethon::Multi' so 3rd argument is supplied
+      prepend_instrument Ethon::Easy, NewRelic::Agent::Instrumentation::Ethon::Easy::Prepend, Ethon::Easy.name
+      prepend_instrument Ethon::Multi, NewRelic::Agent::Instrumentation::Ethon::Multi::Prepend, Ethon::Multi.name
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Ethon::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/excon/middleware.rb

@@ -6,6 +6,7 @@ module ::Excon
   module Middleware
     class NewRelicCrossAppTracing
       TRACE_DATA_IVAR = :@newrelic_trace_data
+      INSTRUMENTATION_NAME = 'Excon'
 
       def initialize(stack)
         @stack = stack
@@ -18,6 +19,8 @@ module ::Excon
           # :idempotent in the options, but there will be only a single
           # accompanying response_call/error_call.
           if datum[:connection] && !datum[:connection].instance_variable_get(TRACE_DATA_IVAR)
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             wrapped_request = ::NewRelic::Agent::HTTPClients::ExconHTTPRequest.new(datum)
             segment = NewRelic::Agent::Tracer.start_external_request_segment(
               library: wrapped_request.type,

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

@@ -9,6 +9,8 @@ module NewRelic::Agent::Instrumentation
     module Instrumentation
       extend self
 
+      INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
       # Since 1.2.0, the class `Grape::API` no longer refers to an API instance, rather, what used to be `Grape::API` is `Grape::API::Instance`
       # https://github.com/ruby-grape/grape/blob/c20a73ac1e3f3ba1082005ed61bf69452373ba87/UPGRADING.md#upgrading-to--120
       def instrumented_class
@@ -46,6 +48,8 @@ module NewRelic::Agent::Instrumentation
       def handle_transaction(endpoint, class_name, version)
         return unless endpoint && route = endpoint.route
 
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         name_transaction(route, class_name, version)
         capture_params(endpoint)
       end

data/lib/new_relic/agent/instrumentation/grpc/client/instrumentation.rb

@@ -12,10 +12,14 @@ module NewRelic
         module Client
           include NewRelic::Agent::Instrumentation::GRPC::Helper
 
+          INSTRUMENTATION_NAME = 'gRPC_Client'
+
           def issue_request_with_tracing(grpc_type, method, requests, marshal, unmarshal,
             deadline:, return_op:, parent:, credentials:, metadata:)
             return yield unless trace_with_newrelic?
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             segment = request_segment(method)
             request_wrapper = NewRelic::Agent::Instrumentation::GRPC::Client::RequestWrapper.new(@host)
             # do not insert CAT headers for gRPC requests https://github.com/newrelic/newrelic-ruby-agent/issues/1730

data/lib/new_relic/agent/instrumentation/grpc/server/instrumentation.rb

@@ -11,6 +11,8 @@ module NewRelic
         module Server
           include NewRelic::Agent::Instrumentation::GRPC::Helper
 
+          INSTRUMENTATION_NAME = 'gRPC_Server'
+
           DT_KEYS = [NewRelic::NEWRELIC_KEY, NewRelic::TRACEPARENT_KEY, NewRelic::TRACESTATE_KEY].freeze
           INSTANCE_VAR_HOST = :@host_nr
           INSTANCE_VAR_PORT = :@port_nr
@@ -23,6 +25,8 @@ module NewRelic
           def handle_with_tracing(streamer_type, active_call, mth, _inter_ctx)
             return yield unless trace_with_newrelic?
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             metadata = metadata_for_call(active_call)
             txn = NewRelic::Agent::Transaction.start_new_transaction(NewRelic::Agent::Tracer.state,
               CATEGORY,

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

@@ -13,7 +13,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    supportability_name = 'gRPC_Client'
+    supportability_name = NewRelic::Agent::Instrumentation::GRPC::Client::INSTRUMENTATION_NAME
     if use_prepend?
       prepend_instrument GRPC::ClientStub, NewRelic::Agent::Instrumentation::GRPC::Client::Prepend, supportability_name
     else

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

@@ -14,7 +14,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    supportability_name = 'gRPC_Server'
+    supportability_name = NewRelic::Agent::Instrumentation::GRPC::Client::INSTRUMENTATION_NAME
     if use_prepend?
       prepend_instrument GRPC::RpcServer, NewRelic::Agent::Instrumentation::GRPC::Server::RpcServerPrepend, supportability_name
       prepend_instrument GRPC::RpcDesc, NewRelic::Agent::Instrumentation::GRPC::Server::RpcDescPrepend, supportability_name

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/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/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/memcache/instrumentation.rb

@@ -10,8 +10,11 @@ module NewRelic::Agent::Instrumentation
       LOCALHOST = 'localhost'
       MULTIGET_METRIC_NAME = 'get_multi_request'
       MEMCACHED = 'Memcached'
+      INSTRUMENTATION_NAME = 'Dalli'
 
       def with_newrelic_tracing(operation, *args)
+        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,6 +48,8 @@ module NewRelic::Agent::Instrumentation
       end
 
       def get_multi_with_newrelic_tracing(method_name)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         segment = NewRelic::Agent::Tracer.start_segment(
           name: "Ruby/Memcached/Dalli/#{method_name}"
         )
@@ -55,6 +62,8 @@ module NewRelic::Agent::Instrumentation
       end
 
       def send_multiget_with_newrelic_tracing(keys)
+        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.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'

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

@@ -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/notifications_subscriber.rb

@@ -47,6 +47,10 @@ 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?
 

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

@@ -4,7 +4,11 @@
 
 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
       rescue => e

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
@@ -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,

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

@@ -34,6 +34,7 @@ DependencyDetection.defer do
 
     subs = %w[send_file
       send_data
+      send_stream
       redirect_to
       halted_callback
       unpermitted_parameters]

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

@@ -7,11 +7,15 @@ module NewRelic
     module Instrumentation
       module Rake
         module Tracer
+          INSTRUMENTATION_NAME = 'Rake'
+
           def invoke_with_newrelic_tracing(*args)
             unless NewRelic::Agent::Instrumentation::Rake.should_trace?(name)
               return yield
             end
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               timeout = NewRelic::Agent.config[:'rake.connect_timeout']
               NewRelic::Agent.instance.wait_on_connect(timeout)

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

@@ -6,6 +6,8 @@ require_relative 'constants'
 
 module NewRelic::Agent::Instrumentation
   module Redis
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def connect_with_tracing
       with_tracing(Constants::CONNECT, database: db) { yield }
     end
@@ -43,6 +45,8 @@ module NewRelic::Agent::Instrumentation
     private
 
     def with_tracing(operation, statement: nil, database: nil)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
         product: Constants::PRODUCT_NAME,
         operation: operation,

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

@@ -6,7 +6,11 @@ module NewRelic::Agent::Instrumentation
   module Resque
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
     def with_tracing
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       begin
         perform_action_with_newrelic_trace(
           :name => 'perform',