newrelic_rpm 9.1.0 → 9.21.0

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

@@ -0,0 +1,36 @@
+# 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 OpenAI::Chain
+    def self.instrument!
+      ::OpenAI::Client.class_eval do
+        include NewRelic::Agent::Instrumentation::OpenAI
+
+        alias_method(:json_post_without_new_relic, :json_post)
+
+        # In versions 4.0.0+ json_post is an instance method
+        # defined in the OpenAI::HTTP module, included by the
+        # OpenAI::Client class
+        def json_post(**kwargs)
+          json_post_with_new_relic(**kwargs) do
+            json_post_without_new_relic(**kwargs)
+          end
+        end
+
+        # In versions below 4.0.0 json_post is a class method
+        # on OpenAI::Client
+        class << self
+          alias_method(:json_post_without_new_relic, :json_post)
+
+          def json_post(**kwargs)
+            json_post_with_new_relic(**kwargs) do
+              json_post_without_new_relic(**kwargs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+# 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 OpenAI
+    VENDOR = 'openAI' # AIM expects this capitalization style for the UI
+    INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+    EMBEDDINGS_PATH = '/embeddings'
+    CHAT_COMPLETIONS_PATH = '/chat/completions'
+    EMBEDDINGS_SEGMENT_NAME = 'Llm/embedding/OpenAI/embeddings'
+    CHAT_COMPLETIONS_SEGMENT_NAME = 'Llm/completion/OpenAI/chat'
+
+    def json_post_with_new_relic(path:, parameters:)
+      return yield unless path == EMBEDDINGS_PATH || path == CHAT_COMPLETIONS_PATH
+
+      NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+      NewRelic::Agent::Llm::LlmEvent.set_llm_agent_attribute_on_transaction
+      record_openai_metric
+
+      if path == EMBEDDINGS_PATH
+        embeddings_instrumentation(parameters) { yield }
+      elsif path == CHAT_COMPLETIONS_PATH
+        chat_completions_instrumentation(parameters) { yield }
+      end
+    end
+
+    private
+
+    def embeddings_instrumentation(parameters)
+      segment = NewRelic::Agent::Tracer.start_segment(name: EMBEDDINGS_SEGMENT_NAME)
+      event = create_embeddings_event(parameters)
+      segment.llm_event = event
+      begin
+        response = NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+        # TODO: Remove !response.include?('error') when we drop support for versions below 4.0.0
+        add_embeddings_response_params(response, event) if response && !response.include?('error')
+
+        response
+      ensure
+        finish(segment, event)
+      end
+    end
+
+    def chat_completions_instrumentation(parameters)
+      segment = NewRelic::Agent::Tracer.start_segment(name: CHAT_COMPLETIONS_SEGMENT_NAME)
+      event = create_chat_completion_summary(parameters)
+      segment.llm_event = event
+      messages = create_chat_completion_messages(parameters, event.id)
+
+      begin
+        response = NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+        # TODO: Remove !response.include?('error') when we drop support for versions below 4.0.0
+        if response && !response.include?('error')
+          add_chat_completion_response_params(parameters, response, event)
+          messages = update_chat_completion_messages(messages, response, event)
+        end
+
+        response
+      ensure
+        finish(segment, event)
+        messages&.each { |m| m.record }
+      end
+    end
+
+    def create_chat_completion_summary(parameters)
+      NewRelic::Agent::Llm::ChatCompletionSummary.new(
+        vendor: VENDOR,
+        request_max_tokens: (parameters[:max_tokens] || parameters['max_tokens'])&.to_i,
+        request_model: parameters[:model] || parameters['model'],
+        request_temperature: (parameters[:temperature] || parameters['temperature'])&.to_f,
+        metadata: llm_custom_attributes
+      )
+    end
+
+    def create_embeddings_event(parameters)
+      event = NewRelic::Agent::Llm::Embedding.new(
+        vendor: VENDOR,
+        request_model: parameters[:model] || parameters['model'],
+        metadata: llm_custom_attributes
+      )
+      add_input(event, (parameters[:input] || parameters['input']))
+
+      event
+    end
+
+    def add_chat_completion_response_params(parameters, response, event)
+      event.response_number_of_messages = (parameters[:messages] || parameters['messages']).size + response['choices'].size
+      # The response hash always returns keys as strings, so we don't need to run an || check here
+      event.response_model = response['model']
+      event.response_choices_finish_reason = response['choices'][0]['finish_reason']
+    end
+
+    def add_embeddings_response_params(response, event)
+      event.response_model = response['model']
+      event.token_count = calculate_token_count(event.request_model, event.input)
+    end
+
+    def create_chat_completion_messages(parameters, summary_id)
+      (parameters[:messages] || parameters['messages']).map.with_index do |message, index|
+        msg = NewRelic::Agent::Llm::ChatCompletionMessage.new(
+          role: message[:role] || message['role'],
+          sequence: index,
+          completion_id: summary_id,
+          vendor: VENDOR
+        )
+        add_content(msg, (message[:content] || message['content']))
+
+        msg
+      end
+    end
+
+    def create_chat_completion_response_messages(response, sequence_origin, summary_id)
+      response['choices'].map.with_index(sequence_origin) do |choice, index|
+        msg = NewRelic::Agent::Llm::ChatCompletionMessage.new(
+          role: choice['message']['role'],
+          sequence: index,
+          completion_id: summary_id,
+          vendor: VENDOR,
+          is_response: true
+        )
+        add_content(msg, choice['message']['content'])
+
+        msg
+      end
+    end
+
+    def update_chat_completion_messages(messages, response, summary)
+      messages += create_chat_completion_response_messages(response, messages.size, summary.id)
+      response_id = response['id'] || NewRelic::Agent::GuidGenerator.generate_guid
+      messages.each do |message|
+        message.id = "#{response_id}-#{message.sequence}"
+        message.request_id = summary.request_id
+        message.response_model = response['model']
+        message.metadata = llm_custom_attributes
+
+        model = message.is_response ? message.response_model : summary.request_model
+
+        message.token_count = calculate_token_count(model, message.content)
+      end
+    end
+
+    def calculate_token_count(model, content)
+      return unless NewRelic::Agent.llm_token_count_callback
+
+      begin
+        count = NewRelic::Agent.llm_token_count_callback.call({model: model, content: content})
+      rescue => e
+        NewRelic::Agent.logger.warn("Error calculating token count using the provided proc. Error: #{e}'")
+      end
+
+      count if count.is_a?(Integer) && count > 0
+    end
+
+    def record_content_enabled?
+      NewRelic::Agent.config[:'ai_monitoring.record_content.enabled']
+    end
+
+    def add_content(message, content)
+      message.content = content if record_content_enabled?
+    end
+
+    def add_input(event, input)
+      event.input = input if record_content_enabled?
+    end
+
+    def llm_custom_attributes
+      NewRelic::Agent::Tracer.current_transaction&.attributes&.custom_attributes&.select { |k| k.to_s.match(/llm.*/) }
+    end
+
+    def record_openai_metric
+      NewRelic::Agent.record_metric(nr_supportability_metric, 0.0)
+    end
+
+    def segment_noticed_error?(segment)
+      segment&.noticed_error
+    end
+
+    def nr_supportability_metric
+      @nr_supportability_metric ||= "Supportability/Ruby/ML/OpenAI/#{::OpenAI::VERSION}"
+    end
+
+    def finish(segment, event)
+      segment&.finish
+
+      return unless event
+
+      if segment
+        event.error = true if segment_noticed_error?(segment)
+        event.duration = segment.duration
+      end
+
+      event.record
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/ruby_openai/prepend.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 OpenAI::Prepend
+    include NewRelic::Agent::Instrumentation::OpenAI
+
+    # In versions 4.0.0+ json_post is an instance method defined in the
+    # OpenAI::HTTP module, included by the OpenAI::Client class.
+    #
+    # In versions below 4.0.0 json_post is a class method on OpenAI::Client.
+    #
+    # Dependency detection will apply the instrumentation to the correct scope,
+    # so we don't need to change the code here.
+    def json_post(**kwargs)
+      json_post_with_new_relic(**kwargs) { super }
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/ruby_openai.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
+
+require_relative 'ruby_openai/instrumentation'
+require_relative 'ruby_openai/chain'
+require_relative 'ruby_openai/prepend'
+
+DependencyDetection.defer do
+  named :'ruby_openai'
+
+  depends_on do
+    NewRelic::Agent.config[:'ai_monitoring.enabled'] &&
+      defined?(OpenAI) && defined?(OpenAI::Client) &&
+      NewRelic::Helper.version_satisfied?(OpenAI::VERSION, '>=', '3.4.0')
+  end
+
+  executes do
+    if use_prepend?
+      # TODO: Remove condition when we drop support for versions below 5.0.0
+      if NewRelic::Helper.version_satisfied?(OpenAI::VERSION, '>=', '5.0.0')
+        prepend_instrument OpenAI::Client,
+          NewRelic::Agent::Instrumentation::OpenAI::Prepend,
+          NewRelic::Agent::Instrumentation::OpenAI::VENDOR
+      else
+        prepend_instrument OpenAI::Client.singleton_class,
+          NewRelic::Agent::Instrumentation::OpenAI::Prepend,
+          NewRelic::Agent::Instrumentation::OpenAI::VENDOR
+      end
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::OpenAI::Chain,
+        NewRelic::Agent::Instrumentation::OpenAI::VENDOR
+    end
+  end
+end

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

@@ -30,7 +30,7 @@ DependencyDetection.defer do
       else
         NewRelic::Agent.logger.info('Detected Sequel version %s.' % [Sequel::VERSION])
         NewRelic::Agent.logger.info('Please see additional documentation: ' +
-          'https://newrelic.com/docs/ruby/sequel-instrumentation')
+          'https://docs.newrelic.com/docs/apm/agents/ruby-agent/frameworks/sequel-instrumentation/')
       end
 
       Sequel.synchronize { Sequel::DATABASES.dup }.each do |db|

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/extensions/delay_extensions.rb

@@ -0,0 +1,24 @@
+# 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
+
+if defined?(Sidekiq::DelayExtensions)
+  class Sidekiq::DelayExtensions::GenericJob
+    def newrelic_trace_args(msg, queue)
+      (target, method_name, *) = ::Sidekiq::DelayExtensions::YAML.unsafe_load(msg['args'][0])
+
+      if target.is_a?(String)
+        target = target.constantize
+      end
+
+      {
+        :name => method_name,
+        :class_name => target.class.name,
+        :category => 'OtherTransaction/SidekiqJob'
+      }
+    rescue => e
+      NewRelic::Agent.logger.error('Failure during deserializing YAML for Sidekiq::DelayExtensions::GenericJob', e)
+      NewRelic::Agent::Instrumentation::Sidekiq::Server.default_trace_args(msg)
+    end
+  end
+end

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

@@ -6,9 +6,9 @@
 #       Delayed extensions are disabled by default in Sidekiq 5 and 6 and
 #       were removed entirely in Sidekiq 7.
 #
-#       see https://github.com/mperham/sidekiq/issues/5076 for the discussion
+#       see https://github.com/sidekiq/sidekiq/issues/5076 for the discussion
 #       of the removal, which includes mentions of alternatives
-if defined?(Sidekiq::VERSION) && Sidekiq::VERSION < '7.0.0'
+if defined?(Sidekiq::VERSION) && NewRelic::Helper.version_satisfied?(Sidekiq::VERSION, '<', '7.0.0')
   class Sidekiq::Extensions::DelayedClass
     def newrelic_trace_args(msg, queue)
       (target, method_name, _args) = if YAML.respond_to?(:unsafe_load)

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

@@ -1,9 +1,11 @@
 # 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 'sidekiq/client'
 require_relative 'sidekiq/server'
 require_relative 'sidekiq/extensions/delayed_class'
+require_relative 'sidekiq/extensions/delay_extensions'
 
 DependencyDetection.defer do
   @name = :sidekiq
@@ -28,28 +30,23 @@ DependencyDetection.defer do
         chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Client)
       end
       config.server_middleware do |chain|
-        chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Server)
+        # We started prepending v chaining NR middleware in 9.18.0 in response to:
+        # https://github.com/newrelic/newrelic-ruby-agent/issues/3037
+        # This way, exceptions resolved by Sidekiq's own middleware are not reported in the agent
+        if chain.respond_to?(:prepend)
+          chain.prepend(NewRelic::Agent::Instrumentation::Sidekiq::Server)
+        else
+          chain.add(NewRelic::Agent::Instrumentation::Sidekiq::Server)
+        end
       end
 
       if config.respond_to?(:error_handlers)
-        config.error_handlers << proc do |error, *_|
+        # Sidekiq 3.0.0 - 7.1.4 expect error_handlers to have 2 arguments
+        # Sidekiq 7.1.5+ expect error_handlers to have 3 arguments
+        config.error_handlers << proc do |error, _ctx, *_|
           NewRelic::Agent.notice_error(error)
         end
       end
     end
   end
-
-  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. ' \
-      'Please upgrade your Sidekiq version to continue receiving full support. '
-
-    NewRelic::Agent.logger.log_once(
-      :warn,
-      :deprecated_sidekiq_version,
-      deprecation_msg
-    )
-  end
 end

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

@@ -33,7 +33,7 @@ module NewRelic::Agent::Instrumentation
         set(:newrelic_ignores, Hash.new([])) if !respond_to?(:newrelic_ignores)
 
         # If we call an ignore without a route, it applies to the whole app
-        routes = ['*'] if routes.empty?
+        routes = [::NewRelic::ASTERISK] if routes.empty?
 
         settings.newrelic_ignores[type] += routes.map do |r|
           # Ugly sending to private Base#compile, but we want to mimic

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/sinatra/transaction_namer.rb

@@ -25,14 +25,12 @@ module NewRelic
             transaction_name(::NewRelic::Agent::UNKNOWN_METRIC, request)
           end
 
-          ROOT = '/'.freeze
-
           def transaction_name(route_text, request)
             verb = http_verb(request)
 
             route_text = route_text.source if route_text.is_a?(Regexp)
             name = route_text.gsub(%r{^[/^\\A]*(.*?)[/\$\?\\z]*$}, '\1')
-            name = ROOT if name.empty?
+            name = NewRelic::ROOT if name.empty?
             name = "#{verb} #{name}" unless verb.nil?
             name
           rescue => e

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

@@ -16,10 +16,6 @@ DependencyDetection.defer do
   depends_on { Sinatra::Base.private_method_defined?(:process_route) }
   depends_on { Sinatra::Base.private_method_defined?(:route_eval) }
 
-  executes do
-    NewRelic::Agent.logger.info('Installing Sinatra instrumentation')
-  end
-
   executes do
     if use_prepend?
       prepend_instrument Sinatra::Base, NewRelic::Agent::Instrumentation::Sinatra::Prepend
@@ -32,27 +28,15 @@ DependencyDetection.defer do
   end
 
   executes do
+    supportability_name = NewRelic::Agent::Instrumentation::Sinatra::Tracer::INSTRUMENTATION_NAME
     # These requires are inside an executes block because they require rack, and
     # we can't be sure that rack is available when this file is first required.
     require 'new_relic/rack/agent_hooks'
     require 'new_relic/rack/browser_monitoring'
     if use_prepend?
-      prepend_instrument Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend
+      prepend_instrument Sinatra::Base.singleton_class, NewRelic::Agent::Instrumentation::Sinatra::Build::Prepend, supportability_name
     else
-      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
+      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain, supportability_name
     end
   end
-
-  executes do
-    next unless Gem::Version.new(Sinatra::VERSION) < Gem::Version.new('2.0.0')
-
-    deprecation_msg = 'The Ruby Agent is dropping support for Sinatra versions below 2.0.0 ' \
-      'in version 9.0.0. Please upgrade your Sinatra version to continue receiving full compatibility. ' \
-
-    NewRelic::Agent.logger.log_once(
-      :warn,
-      :deprecated_sinatra_version,
-      deprecation_msg
-    )
-  end
 end

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) &&
+      NewRelic::Helper.version_satisfied?(Stripe::VERSION, '>=', '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,98 @@
+# 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
+        PATH_PORTION_PATTERN = %r{^/([^/]+/[^/]+)(?:/|\z)}.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)
+          # Grab only the first 2 items from the slash (/) delimited event path.
+          # These items are the API version string and the category. Grabbing
+          # any more of the path will result in unique method names that will
+          # easily grow to be too numerous to sort through in the UI and
+          # possibly even violate default New Relic metric count thresholds.
+          # See newrelic/newrelic-ruby-agent#2654 and
+          # newrelic/newrelic-ruby-agent#2709 for more details.
+          #
+          # In Ruby v3.4 benchmarks, using regex to get at the first two path
+          # elements was seen as more performant than using String#split.
+          #
+          # Regex legend:
+          #
+          # ^ = starts with
+          # / = a literal '/'
+          # () = capture
+          # (?:) = don't capture
+          # [^/]+ = 1 or more characters that are not '/'
+          # /|\z = a literal '/' OR the end of the string
+          path_portion = event.path =~ PATH_PORTION_PATTERN ? Regexp.last_match(1) : NewRelic::UNKNOWN
+          "Stripe/#{path_portion}/#{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