newrelic_rpm 9.4.1 → 9.5.0

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/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',

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

@@ -7,6 +7,8 @@ module NewRelic::Agent::Instrumentation
     module Tracer
       include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
+      INSTRUMENTATION_NAME = 'Roda'
+
       def self.included(clazz)
         clazz.extend(self)
       end
@@ -39,6 +41,8 @@ module NewRelic::Agent::Instrumentation
       end
 
       def _roda_handle_main_route_with_tracing(*args)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         perform_action_with_newrelic_trace(
           category: :roda,
           name: ::NewRelic::Agent::Instrumentation::Roda::TransactionNamer.transaction_name(request),

data/lib/new_relic/agent/instrumentation/roda/roda_transaction_namer.rb

@@ -10,7 +10,7 @@ module NewRelic
           extend self
 
           ROOT = '/'.freeze
-          REGEX_MULTIPLE_SLASHES = %r{^[/^\A]*(.*?)[/$?\z]*$}.freeze
+          REGEX_MULTIPLE_SLASHES = %r{^[/^]*(.*?)[/$?]*$}.freeze
 
           def transaction_name(request)
             path = request.path || ::NewRelic::Agent::UNKNOWN_METRIC

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

@@ -3,6 +3,7 @@
 # frozen_string_literal: true
 
 require_relative 'roda/instrumentation'
+require_relative 'roda/roda_transaction_namer'
 
 DependencyDetection.defer do
   named :roda

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

@@ -6,7 +6,11 @@ module NewRelic::Agent::Instrumentation::Sidekiq
   class Client
     include Sidekiq::ClientMiddleware if defined?(Sidekiq::ClientMiddleware)
 
+    INSTRUMENTATION_NAME = 'SidekiqClient'
+
     def call(_worker_class, job, *_)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       job[NewRelic::NEWRELIC_KEY] ||= distributed_tracing_headers if ::NewRelic::Agent.config[:'distributed_tracing.enabled']
       yield
     end

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

@@ -7,9 +7,16 @@ module NewRelic::Agent::Instrumentation::Sidekiq
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
     include Sidekiq::ServerMiddleware if defined?(Sidekiq::ServerMiddleware)
 
+    ATTRIBUTE_BASE_NAMESPACE = 'sidekiq.args'
+    ATTRIBUTE_FILTER_TYPES = %i[include exclude].freeze
+    ATTRIBUTE_JOB_NAMESPACE = :"job.#{ATTRIBUTE_BASE_NAMESPACE}"
+    INSTRUMENTATION_NAME = 'SidekiqServer'
+
     # Client middleware has additional parameters, and our tests use the
     # middleware client-side to work inline.
     def call(worker, msg, queue, *_)
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
       trace_args = if worker.respond_to?(:newrelic_trace_args)
         worker.newrelic_trace_args(msg, queue)
       else
@@ -18,10 +25,16 @@ module NewRelic::Agent::Instrumentation::Sidekiq
       trace_headers = msg.delete(NewRelic::NEWRELIC_KEY)
 
       perform_action_with_newrelic_trace(trace_args) do
-        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(msg['args'], :'job.sidekiq.args',
-          NewRelic::Agent::AttributeFilter::DST_NONE)
+        NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
+          NewRelic::Agent::AttributePreFiltering.pre_filter(msg['args'], self.class.nr_attribute_options),
+          ATTRIBUTE_JOB_NAMESPACE,
+          NewRelic::Agent::AttributeFilter::DST_NONE
+        )
+
+        if ::NewRelic::Agent.config[:'distributed_tracing.enabled'] && trace_headers&.any?
+          ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, 'Other')
+        end
 
-        ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(trace_headers, 'Other') if ::NewRelic::Agent.config[:'distributed_tracing.enabled'] && trace_headers&.any?
         yield
       end
     end
@@ -33,5 +46,15 @@ module NewRelic::Agent::Instrumentation::Sidekiq
         :category => 'OtherTransaction/SidekiqJob'
       }
     end
+
+    def self.nr_attribute_options
+      @nr_attribute_options ||= begin
+        ATTRIBUTE_FILTER_TYPES.each_with_object({}) do |type, opts|
+          pattern =
+            NewRelic::Agent::AttributePreFiltering.formulate_regexp_union(:"#{ATTRIBUTE_BASE_NAMESPACE}.#{type}")
+          opts[type] = pattern if pattern
+        end.merge(attribute_namespace: ATTRIBUTE_JOB_NAMESPACE)
+      end
+    end
   end
 end

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

@@ -43,8 +43,8 @@ DependencyDetection.defer do
   executes do
     next unless Gem::Version.new(Sidekiq::VERSION) < Gem::Version.new('5.0.0')
 
-    deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated.' \
-      'They will stop being monitored in version 9.0.0. ' \
+    deprecation_msg = 'Instrumentation for Sidekiq versions below 5.0.0 is deprecated ' \
+      'and will be dropped entirely in a future major New Relic Ruby agent release.' \
       'Please upgrade your Sidekiq version to continue receiving full support. '
 
     NewRelic::Agent.logger.log_once(

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

@@ -13,6 +13,8 @@ module NewRelic::Agent::Instrumentation
     module Tracer
       include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
+      INSTRUMENTATION_NAME = 'Sinatra'
+
       def self.included(clazz)
         clazz.extend(self)
       end
@@ -90,6 +92,8 @@ module NewRelic::Agent::Instrumentation
       end
 
       def dispatch_with_tracing
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
         request_params = get_request_params
         filtered_params = ::NewRelic::Agent::ParameterFiltering::apply_filters(request.env, request_params || {})
 

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

@@ -0,0 +1,28 @@
+# 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/instrumentation/stripe_subscriber'
+
+DependencyDetection.defer do
+  named :stripe
+
+  depends_on do
+    NewRelic::Agent.config[:'instrumentation.stripe'] == 'enabled'
+  end
+
+  depends_on do
+    defined?(Stripe) &&
+      Gem::Version.new(Stripe::VERSION) >= Gem::Version.new('5.38.0')
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing Stripe instrumentation')
+  end
+
+  executes do
+    newrelic_subscriber = NewRelic::Agent::Instrumentation::StripeSubscriber.new
+    Stripe::Instrumentation.subscribe(:request_begin) { |event| newrelic_subscriber.start_segment(event) }
+    Stripe::Instrumentation.subscribe(:request_end) { |event| newrelic_subscriber.finish_segment(event) }
+  end
+end

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

@@ -0,0 +1,77 @@
+# 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 Instrumentation
+      class StripeSubscriber
+        DEFAULT_DESTINATIONS = AttributeFilter::DST_SPAN_EVENTS
+        EVENT_ATTRIBUTES = %i[http_status method num_retries path request_id].freeze
+        ATTRIBUTE_NAMESPACE = 'stripe.user_data'
+        ATTRIBUTE_FILTER_TYPES = %i[include exclude].freeze
+
+        def start_segment(event)
+          return unless is_execution_traced?
+
+          segment = NewRelic::Agent::Tracer.start_segment(name: metric_name(event))
+          event.user_data[:newrelic_segment] = segment
+        rescue => e
+          NewRelic::Agent.logger.error("Error starting New Relic Stripe segment: #{e}")
+        end
+
+        def finish_segment(event)
+          return unless is_execution_traced?
+
+          segment = remove_and_return_nr_segment(event)
+          add_stripe_attributes(segment, event)
+          add_custom_attributes(segment, event)
+        rescue => e
+          NewRelic::Agent.logger.error("Error finishing New Relic Stripe segment: #{e}")
+        ensure
+          segment&.finish
+        end
+
+        private
+
+        def is_execution_traced?
+          NewRelic::Agent::Tracer.state.is_execution_traced?
+        end
+
+        def metric_name(event)
+          "Stripe#{event.path}/#{event.method}"
+        end
+
+        def add_stripe_attributes(segment, event)
+          EVENT_ATTRIBUTES.each do |attribute|
+            segment.add_agent_attribute("stripe_#{attribute}", event.send(attribute), DEFAULT_DESTINATIONS)
+          end
+        end
+
+        def add_custom_attributes(segment, event)
+          return if NewRelic::Agent.config[:'stripe.user_data.include'].empty?
+
+          filtered_attributes = NewRelic::Agent::AttributePreFiltering.pre_filter_hash(event.user_data, nr_attribute_options)
+          filtered_attributes.each do |key, value|
+            segment.add_agent_attribute("stripe_user_data_#{key}", value, DEFAULT_DESTINATIONS)
+          end
+        end
+
+        def nr_attribute_options
+          ATTRIBUTE_FILTER_TYPES.each_with_object({}) do |type, opts|
+            pattern =
+              NewRelic::Agent::AttributePreFiltering.formulate_regexp_union(:"#{ATTRIBUTE_NAMESPACE}.#{type}")
+            opts[type] = pattern if pattern
+          end
+        end
+
+        def remove_and_return_nr_segment(event)
+          segment = event.user_data[:newrelic_segment]
+          event.user_data.delete(:newrelic_segment)
+
+          segment
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,8 @@ module NewRelic
   module Agent
     module Instrumentation
       module Tilt
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
         def metric_name(klass, file)
           "View/#{klass}/#{file}/Rendering"
         end
@@ -21,6 +23,8 @@ module NewRelic
         end
 
         def render_with_tracing(*args, &block)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           begin
             finishable = Tracer.start_segment(
               name: metric_name(self.class, create_filename_for_metric(self.file))

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

@@ -8,8 +8,8 @@ module NewRelic
       module Typhoeus
         HYDRA_SEGMENT_NAME = 'External/Multiple/Typhoeus::Hydra/run'
         NOTICEABLE_ERROR_CLASS = 'Typhoeus::Errors::TyphoeusError'
-
         EARLIEST_VERSION = Gem::Version.new('0.5.3')
+        INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
         def self.is_supported_version?
           Gem::Version.new(::Typhoeus::VERSION) >= EARLIEST_VERSION
@@ -31,6 +31,8 @@ module NewRelic
         end
 
         def with_tracing
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           segment = NewRelic::Agent::Tracer.start_segment(name: HYDRA_SEGMENT_NAME)
           instance_variable_set(:@__newrelic_hydra_segment, segment)
           begin
@@ -41,6 +43,8 @@ module NewRelic
         end
 
         def self.trace(request)
+          NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
           state = NewRelic::Agent::Tracer.state
           return unless state.is_execution_traced?
 

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -24,6 +24,9 @@ module NewRelic
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
+        CALLBACK = :@callback
+        SEGMENT = 'segment'
+
         def initialize(name = nil, start_time = nil)
           @name = name
           @starting_segment_key = NewRelic::Agent::Tracer.current_segment_key
@@ -49,6 +52,7 @@ module NewRelic
           @code_function = nil
           @code_lineno = nil
           @code_namespace = nil
+          invoke_callback
         end
 
         def start
@@ -327,6 +331,54 @@ module NewRelic
             Tracer.state
           end
         end
+
+        # for segment callback usage info, see self.set_segment_callback
+        def invoke_callback
+          return unless self.class.instance_variable_defined?(CALLBACK)
+
+          NewRelic::Agent.logger.debug("Invoking callback for #{self.class.name}...")
+          self.class.instance_variable_get(CALLBACK).call
+        end
+
+        # Setting and invoking a segment callback
+        # =======================================
+        # Each individual segment class such as `ExternalRequestSegment` allows
+        # for exactly one instance of a `Proc` (meaning a proc or lambda) to be
+        # set as a callback. A callback can be set on a segment class by calling
+        # `.set_segment_callback` with a proc or lambda as the only argument.
+        # If set, the callback will be invoked with `#call` at segment class
+        # initialization time.
+        #
+        # Example usage:
+        #   callback = -> { puts 'Hello, World! }
+        #   ExternalRequestSegment.set_segment_callback(callback)
+        #   ExternalRequestSegment.new(library, uri, procedure)
+        #
+        # A callback set on a segment class will only be called when that
+        # specific segment class is initialized. Other segment classes will not
+        # be impacted.
+        #
+        # Great caution should be taken in the defining of the callback block
+        # to not have the block perform anything too time consuming or resource
+        # intensive in order to keep the New Relic Ruby agent operating
+        # normally.
+        #
+        # Given that callbacks are user defined, they must be set entirely at
+        # the user's own risk. It is recommended that each callback use
+        # conditional logic that only performs work for certain qualified
+        # segments. It is recommended that each callback be thoroughly tested
+        # in non-production environments before being introduced to production
+        # environments.
+        def self.set_segment_callback(callback_proc)
+          unless callback_proc.is_a?(Proc)
+            NewRelic::Agent.logger.error("#{self}.#{__method__}: expected an argument of type Proc, " \
+                                         "got #{callback_proc.class}")
+            return
+          end
+
+          NewRelic::Agent.record_api_supportability_metric(:set_segment_callback)
+          instance_variable_set(CALLBACK, callback_proc)
+        end
       end
     end
   end

data/lib/new_relic/agent.rb

@@ -58,6 +58,7 @@ module NewRelic
     require 'new_relic/agent/deprecator'
     require 'new_relic/agent/logging'
     require 'new_relic/agent/distributed_tracing'
+    require 'new_relic/agent/attribute_pre_filtering'
     require 'new_relic/agent/attribute_processing'
     require 'new_relic/agent/linking_metadata'
     require 'new_relic/agent/local_log_decorator'
@@ -213,6 +214,17 @@ module NewRelic
       record_metric(metric_name, value)
     end
 
+    def record_instrumentation_invocation(library)
+      record_metric_once("Supportability/#{library}/Invoked")
+    end
+
+    # see ActiveSupport::Inflector.demodulize
+    def base_name(klass_name)
+      return klass_name unless ridx = klass_name.rindex('::')
+
+      klass_name[(ridx + 2), klass_name.length]
+    end
+
     SUPPORTABILITY_INCREMENT_METRIC = 'Supportability/API/increment_metric'.freeze
 
     # Increment a simple counter metric.

data/lib/new_relic/rack/agent_hooks.rb

@@ -23,7 +23,7 @@ module NewRelic::Rack
   #
   class AgentHooks < AgentMiddleware
     def self.needed?
-      !NewRelic::Agent.config[:disable_middleware_instrumentation]
+      NewRelic::Agent.config[:disable_middleware_instrumentation]
     end
 
     def traced_call(env)

data/lib/new_relic/rack/agent_middleware.rb

@@ -26,22 +26,6 @@ module NewRelic
         prefix = ::NewRelic::Agent::Instrumentation::ControllerInstrumentation::TransactionNamer.prefix_for_category(nil, @category)
         "#{prefix}#{self.class.name}/call"
       end
-
-      # If middleware tracing is disabled, we'll still inject our agent-specific
-      # middlewares, and still trace those, but we don't want to capture HTTP
-      # response codes, since middleware that's outside of ours might change the
-      # response code before it goes back to the client.
-      def capture_http_response_code(state, result)
-        return if NewRelic::Agent.config[:disable_middleware_instrumentation]
-
-        super
-      end
-
-      def capture_response_content_type(state, result)
-        return if NewRelic::Agent.config[:disable_middleware_instrumentation]
-
-        super
-      end
     end
   end
 end

data/lib/new_relic/supportability_helper.rb

@@ -46,6 +46,7 @@ module NewRelic
       :recording_web_transaction?,
       :require_test_helper,
       :set_error_group_callback,
+      :set_segment_callback,
       :set_sql_obfuscator,
       :set_transaction_name,
       :set_user_id,

data/lib/new_relic/version.rb

@@ -6,8 +6,8 @@
 module NewRelic
   module VERSION # :nodoc:
     MAJOR = 9
-    MINOR = 4
-    TINY = 1
+    MINOR = 5
+    TINY = 0
 
     STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
   end

data/newrelic.yml

@@ -223,6 +223,9 @@ common: &default_settings
 
   # If true, the agent won't wrap third-party middlewares in instrumentation
   # (regardless of whether they are installed via Rack::Builder or Rails).
+  # 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.
   # disable_middleware_instrumentation: false
 
   # If true, disables agent middleware for Roda. This middleware is responsible for
@@ -494,6 +497,10 @@ common: &default_settings
   # prepend, chain, disabled.
   # instrumentation.sinatra: auto
 
+  # Controls auto-instrumentation of Stripe at startup. May be one of: enabled,
+  # disabled.
+  # instrumentation.stripe: enabled
+
   # Controls auto-instrumentation of the Thread class at start up to allow the agent
   # to correctly nest spans inside of an asynchronous transaction. This does not
   # enable the agent to automatically trace all threads created (see
@@ -585,6 +592,26 @@ common: &default_settings
   # before shutting down.
   # send_data_on_exit: true
 
+  # 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: []
+
+  # 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: []
+
   # If true, the agent collects slow SQL queries.
   # slow_sql.enabled: true
 
@@ -634,6 +661,24 @@ common: &default_settings
   # allowlist. Enabled automatically in high security mode.
   # strip_exception_messages.enabled: false
 
+  # 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.
+  # stripe.user_data.exclude: []
+
+  # 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.
+  # stripe.user_data.include: []
+
   # When set to true, forces a synchronous connection to the New Relic collector
   # during application startup. For very short-lived processes, this helps ensure
   # the New Relic agent has time to report.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 9.4.1
+  version: 9.5.0
 platform: ruby
 authors:
 - Tanna McClure
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-16 00:00:00.000000000 Z
+date: 2023-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -255,6 +255,7 @@ files:
 - lib/new_relic/agent/agent_helpers/transmit.rb
 - lib/new_relic/agent/agent_logger.rb
 - lib/new_relic/agent/attribute_filter.rb
+- lib/new_relic/agent/attribute_pre_filtering.rb
 - lib/new_relic/agent/attribute_processing.rb
 - lib/new_relic/agent/attributes.rb
 - lib/new_relic/agent/audit_logger.rb
@@ -471,6 +472,8 @@ files:
 - lib/new_relic/agent/instrumentation/sinatra/instrumentation.rb
 - lib/new_relic/agent/instrumentation/sinatra/prepend.rb
 - lib/new_relic/agent/instrumentation/sinatra/transaction_namer.rb
+- lib/new_relic/agent/instrumentation/stripe.rb
+- lib/new_relic/agent/instrumentation/stripe_subscriber.rb
 - lib/new_relic/agent/instrumentation/thread.rb
 - lib/new_relic/agent/instrumentation/thread/chain.rb
 - lib/new_relic/agent/instrumentation/thread/instrumentation.rb