newrelic_rpm 9.4.2 → 9.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d061626a8cd184640b8e8bf85c54d475f66f98cadf9385043e91b42d6abff6a
-  data.tar.gz: 29165d5746ceedf8a3cc7862420547e523c6f121a8e3d2b710cf90bb2a3a627c
+  metadata.gz: e5e1f4605a4afe166aa2035486a2433f91f4d0432666b787e6d9c5af9e5ee717
+  data.tar.gz: 16e7707b8c81774ea0c2bea54825d023c2849d0a03ab553e25800c131d9c2972
 SHA512:
-  metadata.gz: e4c874df18c760e0a79c7fd14577b18a291449d73f781e2fb9e48fcb6ddc60bc3e0a8750a146393ac73248a7a68f84b371d9ee908b297f58323cf3095f96f806
-  data.tar.gz: b3d1137d3eb8db15695052498e32069feb4d6f69b20847de646d0fdbd925a5de1bd15895e1f561092fc3cdc66400adc1ef25d16b19ac342fe53ec7acaf2d24c5
+  metadata.gz: 8180f7caa158ce2ea794914376f441f5f912f46fbce8caca074b8c2c9a06fb84ca5e290eab2aa63dfa68f5385e6f7f9f3ede8ee00ee97fbc30d692b93721ec8e
+  data.tar.gz: 21062253bf9236563dcd226ccc4e5e2f8d1fceaed24f6047fb6ed23f485f8b0e4607bbe9b7985c4a63809767c2f4b5785e4ec52c25ff6d2ac186ff7fb8a149f7

data/CHANGELOG.md

@@ -1,5 +1,59 @@
 # New Relic Ruby Agent Release Notes
 
+## v9.5.0
+
+Version 9.5.0 introduces Stripe instrumentation, allows the agent to record additional response information on a transaction when middleware instrumentation is disabled, introduces new `:'sidekiq.args.include'` and `:'sidekiq.args.exclude:` configuration options to permit capturing only certain Sidekiq job arguments, updates Elasticsearch datastore instance metrics, and fixes a bug in `NewRelic::Rack::AgentHooks.needed?`.
+
+- **Feature: Add Stripe instrumentation**
+
+  [Stripe](https://stripe.com/) calls are now automatically instrumented. Additionally, new `:'stripe.user_data.include'` and `:'stripe.user_data.exclude'` configuration options permit capturing custom `user_data` key-value pairs that can be stored in [Stripe events](https://github.com/stripe/stripe-ruby#instrumentation). No `user_data` key-value pairs are captured by default. The agent currently supports Stripe versions 5.38.0+. [PR#2180](https://github.com/newrelic/newrelic-ruby-agent/pull/2180)
+
+- **Feature: Report transaction HTTP status codes when middleware instrumentation is disabled**
+
+  Previously, when `disable_middleware_instrumentation` was set to `true`, the agent would not record the value of the response code or content type on the transaction. This was due to the possibility that a middleware could alter the response, which would not be captured by the agent when the middleware instrumentation was disabled. However, based on customer feedback, the agent will now report the HTTP status code and content type on a transaction when middleware instrumentation is disabled. [PR#2175](https://github.com/newrelic/newrelic-ruby-agent/pull/2175)
+
+- **Feature: Permit capturing only certain Sidekiq job arguments**
+
+  New `:'sidekiq.args.include'` and `:'sidekiq.args.exclude'` configuration options have been introduced to permit fine grained control over which Sidekiq job arguments (args) are reported to New Relic. By default, no Sidekiq args are reported. To report any Sidekiq options, the `:'attributes.include'` array must include the string `'jobs.sidekiq.args.*'`. With that string in place, all arguments will be reported unless one or more of the new include/exclude options are used. The `:'sidekiq.args.include'` option can be set to an array of strings. Each of those strings will be passed to `Regexp.new` and collectively serve as an allowlist for desired args. For job arguments that are hashes, if a hash's key matches one of the include patterns, then both the key and its corresponding value will be included. For scalar arguments, the string representation of the scalar will need to match one of the include patterns to be captured. The `:'sidekiq.args.exclude'` option works similarly. It can be set to an array of strings that will each be passed to `Regexp.new` to create patterns. These patterns will collectively serve as a denylist for unwanted job args. Any hash key, hash value, or scalar that matches an exclude pattern will be excluded (not sent to New Relic). [PR#2177](https://github.com/newrelic/newrelic-ruby-agent/pull/2177)
+
+  `newrelic.yml` examples:
+
+  Any string in the `:'sidekiq.args.include'` or `:'sidekiq.args.exclude'` arrays will be turned into a regular expression. Knowledge of [Ruby regular expression support](https://ruby-doc.org/3.2.2/Regexp.html) can be leveraged but is not required. If regular expression syntax is not used, inexact matches will be performed and the string "Fortune" will match both "Fortune 500" and "Fortune and Glory". For exact matches, use [regular expression anchors](https://ruby-doc.org/3.2.2/Regexp.html#class-Regexp-label-Anchors).
+
+  ```yaml
+  # Include any argument whose string representation matches either "apple" or "banana"
+  # The "apple" pattern will match both "green apple" and "red apple"
+  sidekiq.args.include:
+    - apple
+    - banana
+
+  # Exclude any arguments that match either "grape", "orange", or "pear"
+  sidekiq.args.exclude:
+    - grape
+    - orange
+    - pear
+
+  # Exclude any argument that is a 9 digit number
+  sidekiq.args.exclude:
+    - '\d{9}'
+
+  # Include anything that starts with "blue" but exclude anything that ends in "green"
+  sidekiq.args.include
+    - '^blue'
+
+  sidekiq.args.exclude
+    - 'green$'
+  ```
+
+- **Bugfix: Update Elasticsearch datastore instance metric to use port instead of path**
+
+  Previously, the Elasticsearch datastore instance metric (`Datastore/instance/Elasticsearch/<host>/*`) used the path as the final value. This caused a [metrics grouping issue](https://docs.newrelic.com/docs/new-relic-solutions/solve-common-issues/troubleshooting/metric-grouping-issues) for some users, as every document ID created a unique metric. Now, the datastore instance metric has been updated to use the port as the final value. This also has the benefit of being more accurate for datastore instance metrics, as this port is directly associated with the already listed host.
+
+- **Bugfix: Resolve inverted logic of NewRelic::Rack::AgentHooks.needed?**
+
+  Previously, `NewRelic::Rack::AgentHooks.needed?` incorrectly used inverted logic. This has now been resolved, allowing AgentHooks to be installed when `disable_middleware_instrumentation` is set to true. [PR#2175](https://github.com/newrelic/newrelic-ruby-agent/pull/2175)
+
+
 ## v9.4.2
 
 Version 9.4.2 of the agent re-addresses the 9.4.0 issue of `NoMethodError` seen when using the `uppy-s3_multipart` gem.
@@ -27,19 +81,19 @@ Version 9.4.0 of the agent adds [Roda](https://roda.jeremyevans.net/) instrument
 - **Feature: New allow_all_headers configuration option**
 
   A new `allow_all_headers` configuration option brings parity with the [Node.js agent](https://docs.newrelic.com/docs/release-notes/agent-release-notes/nodejs-release-notes/node-agent-270/) to capture all HTTP request headers.
-  
+
   This configuration option:
     * Defaults to `false`
     * Is not compatible with high security mode
-    * Requires Rack version 2 or higher (as does Ruby on Rails version 5 and above) 
+    * Requires Rack version 2 or higher (as does Ruby on Rails version 5 and above)
     * Respects all existing behavior for the `attributes.include` and `attributes.exclude` [configuration options](https://docs.newrelic.com/docs/apm/agents/ruby-agent/configuration/ruby-agent-configuration/#attributes)
     * Captures the additional headers as attributes prefixed with `request.headers.`
-  
+
   This work was done in response to a feature request submitted by community member [@jamesarosen](https://github.com/jamesarosen). Thank you very much, @jamesarosen! [Issue#1029](https://github.com/newrelic/newrelic-ruby-agent/issues/1029)
 
 - **Feature: Improved error tracking transaction linking**
 
-  Errors tracked and sent to the New Relic errors inbox will now be associated with a transaction id to enable improved UI/UX associations between transactions and errors. [PR#2035](https://github.com/newrelic/newrelic-ruby-agent/pull/2035) 
+  Errors tracked and sent to the New Relic errors inbox will now be associated with a transaction id to enable improved UI/UX associations between transactions and errors. [PR#2035](https://github.com/newrelic/newrelic-ruby-agent/pull/2035)
 
 - **Feature: Use Net::HTTP native timeout logic**
 

data/lib/new_relic/agent/attribute_pre_filtering.rb

@@ -0,0 +1,109 @@
+# 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
+  module Agent
+    module AttributePreFiltering
+      module_function
+
+      PRE_FILTER_KEYS = %i[include exclude].freeze
+      DISCARDED = :nr_discarded
+
+      def formulate_regexp_union(option)
+        return if NewRelic::Agent.config[option].empty?
+
+        Regexp.union(NewRelic::Agent.config[option].map { |p| string_to_regexp(p) }.uniq.compact).freeze
+      rescue StandardError => e
+        NewRelic::Agent.logger.warn("Failed to formulate a Regexp union from the '#{option}' configuration option " +
+                                    "- #{e.class}: #{e.message}")
+      end
+
+      def string_to_regexp(str)
+        Regexp.new(str)
+      rescue StandardError => e
+        NewRelic::Agent.logger.warn("Failed to initialize Regexp from string '#{str}' - #{e.class}: #{e.message}")
+      end
+
+      # attribute filtering suppresses data that has already been flattened
+      # and coerced (serialized as text) via #flatten_and_coerce, and is
+      # restricted to basic text matching with a single optional wildcard.
+      # pre filtering operates on raw Ruby objects beforehand and uses full
+      # Ruby regex syntax
+      def pre_filter(values = [], options = {})
+        return values unless !options.empty? && PRE_FILTER_KEYS.any? { |k| options.key?(k) }
+
+        # if there's a prefix in play for (non-pre) attribute filtration and
+        # attribute filtration won't allow that prefix, then don't even bother
+        # with pre filtration that could only result in values that would be
+        # blocked
+        if options.key?(:attribute_namespace) &&
+            !NewRelic::Agent.instance.attribute_filter.might_allow_prefix?(options[:attribute_namespace])
+          return values
+        end
+
+        values.each_with_object([]) do |element, filtered|
+          object = pre_filter_object(element, options)
+          filtered << object unless discarded?(object)
+        end
+      end
+
+      def pre_filter_object(object, options)
+        if object.is_a?(Hash)
+          pre_filter_hash(object, options)
+        elsif object.is_a?(Array)
+          pre_filter_array(object, options)
+        else
+          pre_filter_scalar(object, options)
+        end
+      end
+
+      def pre_filter_hash(hash, options)
+        filtered_hash = hash.each_with_object({}) do |(key, value), filtered|
+          filtered_key = pre_filter_object(key, options)
+          next if discarded?(filtered_key)
+
+          # If the key is permitted, skip include filtration for the value
+          # but still apply exclude filtration
+          if options.key?(:exclude)
+            exclude_only = options.dup
+            exclude_only.delete(:include)
+            filtered_value = pre_filter_object(value, exclude_only)
+            next if discarded?(filtered_value)
+          else
+            filtered_value = value
+          end
+
+          filtered[filtered_key] = filtered_value
+        end
+
+        filtered_hash.empty? && !hash.empty? ? DISCARDED : filtered_hash
+      end
+
+      def pre_filter_array(array, options)
+        filtered_array = array.each_with_object([]) do |element, filtered|
+          filtered_element = pre_filter_object(element, options)
+          next if discarded?(filtered_element)
+
+          filtered.push(filtered_element)
+        end
+
+        filtered_array.empty? && !array.empty? ? DISCARDED : filtered_array
+      end
+
+      def pre_filter_scalar(scalar, options)
+        return DISCARDED if options.key?(:include) && !scalar.to_s.match?(options[:include])
+        return DISCARDED if options.key?(:exclude) && scalar.to_s.match?(options[:exclude])
+
+        scalar
+      end
+
+      # `nil`, empty enumerable objects, and `false` are all valid in their
+      # own right as application data, so pre-filtering uses a special value
+      # to indicate that filtered out data has been discarded
+      def discarded?(object)
+        object == DISCARDED
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration/default_source.rb

@@ -3,6 +3,7 @@
 # frozen_string_literal: true
 
 require 'forwardable'
+require_relative '../../constants'
 
 module NewRelic
   module Agent
@@ -1212,7 +1213,13 @@ module NewRelic
           :public => true,
           :type => Boolean,
           :allowed_from_server => false,
-          :description => 'If `true`, the agent won\'t wrap third-party middlewares in instrumentation (regardless of whether they are installed via `Rack::Builder` or Rails).'
+          :description => <<~DESCRIPTION
+            If `true`, the agent won't wrap third-party middlewares in instrumentation (regardless of whether they are installed via `Rack::Builder` or Rails).
+
+              <Callout variant="important">
+                When middleware instrumentation is disabled, if an application is using middleware that could alter the response code, the HTTP status code reported on the transaction may not reflect the altered value.
+              </Callout>
+          DESCRIPTION
         },
         :disable_samplers => {
           :default => false,
@@ -1595,6 +1602,41 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'Controls auto-instrumentation of Sinatra at start up. May be one of: `auto`, `prepend`, `chain`, `disabled`.'
         },
+        :'instrumentation.stripe' => {
+          :default => 'enabled',
+          :public => true,
+          :type => String,
+          :allowed_from_server => false,
+          :description => 'Controls auto-instrumentation of Stripe at startup. May be one of: `enabled`, `disabled`.'
+        },
+        :'stripe.user_data.include' => {
+          default: NewRelic::EMPTY_ARRAY,
+          public: true,
+          type: Array,
+          dynamic_name: true,
+          allowed_from_server: false,
+          :transform => DefaultSource.method(:convert_to_list),
+          :description => <<~DESCRIPTION
+            An array of strings to specify which keys inside a Stripe event's `user_data` hash should be reported
+            to New Relic. Each string in this array will be turned into a regular expression via `Regexp.new` to
+            permit advanced matching. Setting the value to `["."]` will report all `user_data`.
+          DESCRIPTION
+        },
+        :'stripe.user_data.exclude' => {
+          default: NewRelic::EMPTY_ARRAY,
+          public: true,
+          type: Array,
+          dynamic_name: true,
+          allowed_from_server: false,
+          :transform => DefaultSource.method(:convert_to_list),
+          :description => <<~DESCRIPTION
+            An array of strings to specify which keys and/or values inside a Stripe event's `user_data` hash should
+            not be reported to New Relic. Each string in this array will be turned into a regular expression via
+            `Regexp.new` to permit advanced matching. For each hash pair, if either the key or value is matched the
+            pair will not be reported. By default, no `user_data` is reported, so this option should only be used if 
+            the `stripe.user_data.include` option is being used.
+          DESCRIPTION
+        },
         :'instrumentation.thread' => {
           :default => 'auto',
           :public => true,
@@ -1709,6 +1751,37 @@ module NewRelic
           :transform => DefaultSource.method(:convert_to_regexp_list),
           :description => 'Define transactions you want the agent to ignore, by specifying a list of patterns matching the URI you want to ignore. For more detail, see [the docs on ignoring specific transactions](/docs/agents/ruby-agent/api-guides/ignoring-specific-transactions/#config-ignoring).'
         },
+        # Sidekiq
+        :'sidekiq.args.include' => {
+          default: NewRelic::EMPTY_ARRAY,
+          public: true,
+          type: Array,
+          dynamic_name: true,
+          allowed_from_server: false,
+          description: <<~SIDEKIQ_ARGS_INCLUDE.chomp.tr("\n", ' ')
+            An array of strings that will collectively serve as an allowlist for filtering which Sidekiq
+            job arguments get reported to New Relic. To capture any Sidekiq arguments,
+            'job.sidekiq.args.*' must be added to the separate `:'attributes.include'` configuration option. Each
+            string in this array will be turned into a regular expression via `Regexp.new` to permit advanced
+            matching. For job argument hashes, if either a key or value matches the pair will be included. All
+            matching job argument array elements and job argument scalars will be included.
+          SIDEKIQ_ARGS_INCLUDE
+        },
+        :'sidekiq.args.exclude' => {
+          default: NewRelic::EMPTY_ARRAY,
+          public: true,
+          type: Array,
+          dynamic_name: true,
+          allowed_from_server: false,
+          description: <<~SIDEKIQ_ARGS_EXCLUDE.chomp.tr("\n", ' ')
+            An array of strings that will collectively serve as a denylist for filtering which Sidekiq
+            job arguments get reported to New Relic. To capture any Sidekiq arguments,
+            'job.sidekiq.args.*' must be added to the separate `:'attributes.include'` configuration option. Each string
+            in this array will be turned into a regular expression via `Regexp.new` to permit advanced matching.
+            For job argument hashes, if either a key or value matches the pair will be excluded. All matching job
+            argument array elements and job argument scalars will be excluded.
+          SIDEKIQ_ARGS_EXCLUDE
+        },
         # Slow SQL
         :'slow_sql.enabled' => {
           :default => value_of(:'transaction_tracer.enabled'),

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

@@ -6,8 +6,12 @@ module NewRelic
   module Agent
     module Instrumentation
       module ActiveSupportLogger
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
         # Mark @skip_instrumenting on any broadcasted loggers to instrument Rails.logger only
         def broadcast_with_tracing(logger)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           NewRelic::Agent::Instrumentation::Logger.mark_skip_instrumenting(logger)
           yield
         rescue => error

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

@@ -12,6 +12,7 @@ module NewRelic
         DEFAULT_NAME = 'Default'
         DEFAULT_TYPE = :direct
         SLASH = '/'
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
         def exchange_name(name)
           name.empty? ? DEFAULT_NAME : name
@@ -28,6 +29,8 @@ module NewRelic
           include Bunny
 
           def publish_with_tracing(payload, opts = {})
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               destination = exchange_name(name)
 
@@ -62,6 +65,8 @@ module NewRelic
           include Bunny
 
           def pop_with_tracing
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
             begin
               t0 = Process.clock_gettime(Process::CLOCK_REALTIME)
@@ -104,6 +109,8 @@ module NewRelic
           end
 
           def purge_with_tracing
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             begin
               type = server_named? ? :temporary_queue : :queue
               segment = NewRelic::Agent::Tracer.start_message_broker_segment(
@@ -129,6 +136,8 @@ module NewRelic
           include Bunny
 
           def call_with_tracing(*args)
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             delivery_info, message_properties, _ = args
             queue_name = queue.respond_to?(:name) ? queue.name : queue
 

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

@@ -5,10 +5,10 @@
 module NewRelic::Agent::Instrumentation
   module ConcurrentRuby
     SEGMENT_NAME = 'Concurrent/Task'
-    SUPPORTABILITY_METRIC = 'Supportability/ConcurrentRuby/Invoked'
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
     def add_task_tracing(&task)
-      NewRelic::Agent.record_metric_once(SUPPORTABILITY_METRIC)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
 
       NewRelic::Agent::Tracer.thread_block_with_current_transaction(
         segment_name: SEGMENT_NAME,

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

@@ -68,6 +68,8 @@ module NewRelic
         module Multi
           include NewRelic::Agent::MethodTracer
 
+          INSTRUMENTATION_NAME = 'Curb'
+
           # Add CAT with callbacks if the request is serial
           def add_with_tracing(curl)
             if curl.respond_to?(:_nr_serial) && curl._nr_serial
@@ -81,6 +83,8 @@ module NewRelic
           def perform_with_tracing
             return yield if first_request_is_serial?
 
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
             trace_execution_scoped('External/Multiple/Curb::Multi/perform') do
               yield
             end

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

@@ -31,8 +31,11 @@ module NewRelic
         include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
         NR_TRANSACTION_CATEGORY = 'OtherTransaction/DelayedJob'.freeze
+        INSTRUMENTATION_NAME = 'DelayedJob'
 
         def invoke_job_with_tracing
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           options = {
             :category => NR_TRANSACTION_CATEGORY,
             :path => ::NewRelic::Agent::Instrumentation::DelayedJob::Naming.name_from_payload(payload_object)

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

@@ -8,15 +8,18 @@ module NewRelic::Agent::Instrumentation
   module Elasticsearch
     PRODUCT_NAME = 'Elasticsearch'
     OPERATION = 'perform_request'
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
     def perform_request_with_tracing(method, path, params = {}, body = nil, headers = nil)
       return yield unless NewRelic::Agent::Tracer.tracing_enabled?
 
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       segment = NewRelic::Agent::Tracer.start_datastore_segment(
         product: PRODUCT_NAME,
         operation: nr_operation || OPERATION,
         host: nr_hosts[:host],
-        port_path_or_id: path,
+        port_path_or_id: nr_hosts[:port],
         database_name: nr_cluster_name
       )
       begin

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/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/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(

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