newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -0,0 +1,55 @@
+# 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 Sinatra
+    module Chain
+      def self.instrument!
+        ::Sinatra::Base.class_eval do
+          include ::NewRelic::Agent::Instrumentation::Sinatra::Tracer
+
+          def dispatch_with_newrelic
+            dispatch_with_tracing { dispatch_without_newrelic }
+          end
+          alias dispatch_without_newrelic dispatch!
+          alias dispatch! dispatch_with_newrelic
+
+          def process_route_with_newrelic(*args, &block)
+            process_route_with_tracing(*args) do
+              process_route_without_newrelic(*args, &block)
+            end
+          end
+          alias process_route_without_newrelic process_route
+          alias process_route process_route_with_newrelic
+
+          def route_eval_with_newrelic(*args, &block)
+            route_eval_with_tracing(*args) do
+              route_eval_without_newrelic(*args, &block)
+            end
+          end
+          alias route_eval_without_newrelic route_eval
+          alias route_eval route_eval_with_newrelic
+        end
+      end
+    end
+
+    module Build
+      module Chain
+        def self.instrument!
+          ::Sinatra::Base.class_eval do
+            class << self
+              def build_with_newrelic(*args, &block)
+                build_with_tracing(*args) do
+                  build_without_newrelic(*args, &block)
+                end
+              end
+              alias build_without_newrelic build
+              alias build build_with_newrelic
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,50 +1,44 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Sinatra
-        module Ignorer
+module NewRelic::Agent::Instrumentation
+  module Sinatra
+    module Ignorer
+      def self.should_ignore?(app, type)
+        return false if !app.settings.respond_to?(:newrelic_ignores)
 
-          def self.should_ignore?(app, type)
-            return false if !app.settings.respond_to?(:newrelic_ignores)
-
-            app.settings.newrelic_ignores[type].any? do |pattern|
-              pattern.match(app.request.path_info)
-            end
-          end
-
-          def newrelic_ignore(*routes)
-            set_newrelic_ignore(:routes, *routes)
-          end
+        app.settings.newrelic_ignores[type].any? do |pattern|
+          pattern.match(app.request.path_info)
+        end
+      end
 
-          def newrelic_ignore_apdex(*routes)
-            set_newrelic_ignore(:apdex, *routes)
-          end
+      def newrelic_ignore(*routes)
+        set_newrelic_ignore(:routes, *routes)
+      end
 
-          def newrelic_ignore_enduser(*routes)
-            set_newrelic_ignore(:enduser, *routes)
-          end
+      def newrelic_ignore_apdex(*routes)
+        set_newrelic_ignore(:apdex, *routes)
+      end
 
-          private
+      def newrelic_ignore_enduser(*routes)
+        set_newrelic_ignore(:enduser, *routes)
+      end
 
-          def set_newrelic_ignore(type, *routes)
-            # Important to default this in the context of the actual app
-            # If it's done at register time, ignores end up shared between apps.
-            set :newrelic_ignores, Hash.new([]) if !respond_to?(:newrelic_ignores)
+      private
 
-            # If we call an ignore without a route, it applies to the whole app
-            routes = ["*"] if routes.empty?
+      def set_newrelic_ignore(type, *routes)
+        # Important to default this in the context of the actual app
+        # If it's done at register time, ignores end up shared between apps.
+        set(:newrelic_ignores, Hash.new([])) if !respond_to?(:newrelic_ignores)
 
-            settings.newrelic_ignores[type] += routes.map do |r|
-              # Ugly sending to private Base#compile, but we want to mimic
-              # exactly Sinatra's mapping of route text to regex
-              send(:compile, r).first
-            end
-          end
+        # If we call an ignore without a route, it applies to the whole app
+        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
+          # exactly Sinatra's mapping of route text to regex
+          Array(send(:compile, r)).first
         end
       end
     end

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

@@ -0,0 +1,130 @@
+# 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
+
+# NewRelic instrumentation for Sinatra applications.  Sinatra actions will
+# appear in the UI similar to controller actions, and have breakdown charts
+# and transaction traces.
+#
+# The actions in the UI will correspond to the pattern expression used
+# to match them, not directly to full URL's.
+module NewRelic::Agent::Instrumentation
+  module Sinatra
+    module Tracer
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      INSTRUMENTATION_NAME = 'Sinatra'
+
+      def self.included(clazz)
+        clazz.extend(self)
+      end
+
+      # Expected method for supporting ControllerInstrumentation
+      def newrelic_request_headers(_)
+        request.env
+      end
+
+      def newrelic_middlewares
+        middlewares = [NewRelic::Rack::BrowserMonitoring]
+        if NewRelic::Rack::AgentHooks.needed?
+          middlewares << NewRelic::Rack::AgentHooks
+        end
+        middlewares
+      end
+
+      def build_with_tracing(*args, &block)
+        unless NewRelic::Agent.config[:disable_sinatra_auto_middleware]
+          newrelic_middlewares.each do |middleware_class|
+            try_to_use(self, middleware_class)
+          end
+        end
+        yield
+      end
+
+      def install_lock
+        @install_lock ||= Mutex.new
+      end
+
+      def try_to_use(app, clazz)
+        install_lock.synchronize do
+          # The following line needs else branch coverage
+          has_middleware = app.middleware && app.middleware.any? { |info| info && info[0] == clazz } # rubocop:disable Style/SafeNavigation
+          app.use(clazz) unless has_middleware
+        end
+      end
+
+      # Capture last route we've seen. Will set for transaction on route_eval
+      def process_route_with_tracing(*args)
+        begin
+          env['newrelic.last_route'] = args[0]
+        rescue => e
+          ::NewRelic::Agent.logger.debug('Failed determining last route in Sinatra', e)
+        end
+        yield
+      end
+
+      # If a transaction name is already set, this call will tromple over it.
+      # This is intentional, as typically passing to a separate route is like
+      # an entirely separate transaction, so we pick up the new name.
+      #
+      # If we're ignored, this remains safe, since set_transaction_name
+      # care for the gating on the transaction's existence for us.
+      def route_eval_with_tracing(*args)
+        begin
+          if txn_name = TransactionNamer.transaction_name_for_route(env, request)
+            ::NewRelic::Agent::Transaction.set_default_transaction_name(
+              "#{self.class.name}/#{txn_name}", :sinatra
+            )
+          end
+        rescue => e
+          ::NewRelic::Agent.logger.debug('Failed during route_eval to set transaction name', e)
+        end
+        yield
+      end
+
+      def get_request_params
+        begin
+          @request.params
+        rescue => e
+          NewRelic::Agent.logger.debug('Failed to get params from Rack request.', e)
+          nil
+        end
+      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 || {})
+
+        name = TransactionNamer.initial_transaction_name(request)
+        perform_action_with_newrelic_trace(:category => :sinatra,
+          :name => name,
+          :params => filtered_params) do
+          begin
+            yield
+          ensure
+            # Will only see an error raised if :show_exceptions is true, but
+            # will always see them in the env hash if they occur
+            had_error = env.has_key?('sinatra.error')
+            ::NewRelic::Agent.notice_error(env['sinatra.error']) if had_error
+          end
+        end
+      end
+
+      def do_not_trace?
+        Ignorer.should_ignore?(self, :routes)
+      end
+
+      # Overrides ControllerInstrumentation implementation
+      def ignore_apdex?
+        Ignorer.should_ignore?(self, :apdex)
+      end
+
+      # Overrides ControllerInstrumentation implementation
+      def ignore_enduser?
+        Ignorer.should_ignore?(self, :enduser)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# 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 Sinatra
+    module Prepend
+      include ::NewRelic::Agent::Instrumentation::Sinatra::Tracer
+
+      def dispatch!
+        dispatch_with_tracing { super }
+      end
+
+      def process_route(*args, &block)
+        process_route_with_tracing(*args) { super }
+      end
+
+      def route_eval(*args, &block)
+        route_eval_with_tracing(*args) { super }
+      end
+    end
+
+    module Build
+      module Prepend
+        include ::NewRelic::Agent::Instrumentation::Sinatra::Tracer
+
+        def build(*args, &block)
+          build_with_tracing(*args) { super }
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -9,11 +9,16 @@ module NewRelic
         module TransactionNamer
           extend self
 
-          def transaction_name_for_route(env, request)
-            name = route_for_sinatra(env)
-            name = route_name_for_padrino(request) if name.nil?
+          SINATRA_ROUTE = 'sinatra.route'
 
-            transaction_name(name, request) unless name.nil?
+          def transaction_name_for_route(env, request)
+            if env.key?(SINATRA_ROUTE)
+              env[SINATRA_ROUTE]
+            else
+              name = route_for_sinatra(env)
+              name = route_name_for_padrino(request) if name.nil?
+              transaction_name(name, request) unless name.nil?
+            end
           end
 
           def initial_transaction_name(request)
@@ -25,6 +30,7 @@ module NewRelic
 
             route_text = route_text.source if route_text.is_a?(Regexp)
             name = route_text.gsub(%r{^[/^\\A]*(.*?)[/\$\?\\z]*$}, '\1')
+            name = NewRelic::ROOT if name.empty?
             name = "#{verb} #{name}" unless verb.nil?
             name
           rescue => e
@@ -39,7 +45,7 @@ module NewRelic
           # For bare Sinatra, our override on process_route captures the last
           # route into the environment for us to use later on
           def route_for_sinatra(env)
-            env["newrelic.last_route"]
+            env['newrelic.last_route']
           end
 
           # For Padrino, the request object has a copy of the matched route

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

@@ -1,188 +1,58 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-require 'new_relic/agent/instrumentation/controller_instrumentation'
-require 'new_relic/agent/instrumentation/sinatra/transaction_namer'
-require 'new_relic/agent/instrumentation/sinatra/ignorer'
+require_relative 'sinatra/transaction_namer'
+require_relative 'sinatra/ignorer'
+require_relative 'sinatra/instrumentation'
+require_relative 'sinatra/chain'
+require_relative 'sinatra/prepend'
 
 DependencyDetection.defer do
-  @name = :sinatra
+  named :sinatra
 
-  depends_on do
-    !NewRelic::Agent.config[:disable_sinatra] &&
-      defined?(::Sinatra) && defined?(::Sinatra::Base) &&
-      Sinatra::Base.private_method_defined?(:dispatch!) &&
-      Sinatra::Base.private_method_defined?(:process_route) &&
-      Sinatra::Base.private_method_defined?(:route_eval)
-  end
+  depends_on { defined?(Sinatra) && defined?(Sinatra::Base) }
+  depends_on { Sinatra::Base.private_method_defined?(:dispatch!) }
+  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'
+    NewRelic::Agent.logger.info('Installing Sinatra instrumentation')
   end
 
   executes do
-    ::Sinatra::Base.class_eval do
-      include NewRelic::Agent::Instrumentation::Sinatra
-
-      alias dispatch_without_newrelic dispatch!
-      alias dispatch! dispatch_with_newrelic
-
-      alias process_route_without_newrelic process_route
-      alias process_route process_route_with_newrelic
-
-      alias route_eval_without_newrelic route_eval
-      alias route_eval route_eval_with_newrelic
-
-      register NewRelic::Agent::Instrumentation::Sinatra::Ignorer
+    if use_prepend?
+      prepend_instrument Sinatra::Base, NewRelic::Agent::Instrumentation::Sinatra::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Chain
     end
 
-    module ::Sinatra
-      register NewRelic::Agent::Instrumentation::Sinatra::Ignorer
-    end
+    Sinatra::Base.class_eval { register NewRelic::Agent::Instrumentation::Sinatra::Ignorer }
+    Sinatra.module_eval { register NewRelic::Agent::Instrumentation::Sinatra::Ignorer }
   end
 
   executes do
-    if Sinatra::Base.respond_to?(:build)
-      # 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'
-      require 'new_relic/rack/error_collector'
-
-      ::Sinatra::Base.class_eval do
-        class << self
-          alias build_without_newrelic build
-          alias build build_with_newrelic
-        end
-      end
+    # 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
     else
-      ::NewRelic::Agent.logger.info("Skipping auto-injection of middleware for Sinatra - requires Sinatra 1.2.1+")
+      chain_instrument NewRelic::Agent::Instrumentation::Sinatra::Build::Chain
     end
   end
-end
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      # NewRelic instrumentation for Sinatra applications.  Sinatra actions will
-      # appear in the UI similar to controller actions, and have breakdown charts
-      # and transaction traces.
-      #
-      # The actions in the UI will correspond to the pattern expression used
-      # to match them, not directly to full URL's.
-      module Sinatra
-        include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-        # Expected method for supporting ControllerInstrumentation
-        def newrelic_request_headers(_)
-          request.env
-        end
-
-        def self.included(clazz)
-          clazz.extend(ClassMethods)
-        end
-
-        module ClassMethods
-          def newrelic_middlewares
-            middlewares = [NewRelic::Rack::BrowserMonitoring]
-            if NewRelic::Rack::AgentHooks.needed?
-              middlewares << NewRelic::Rack::AgentHooks
-            end
-            middlewares
-          end
 
-          def build_with_newrelic(*args, &block)
-            unless NewRelic::Agent.config[:disable_sinatra_auto_middleware]
-              newrelic_middlewares.each do |middleware_class|
-                try_to_use(self, middleware_class)
-              end
-            end
-            build_without_newrelic(*args, &block)
-          end
-
-          def try_to_use(app, clazz)
-            has_middleware = app.middleware.any? { |info| info[0] == clazz }
-            app.use(clazz) unless has_middleware
-          end
-        end
-
-        # Capture last route we've seen. Will set for transaction on route_eval
-        def process_route_with_newrelic(*args, &block)
-          begin
-            env["newrelic.last_route"] = args[0]
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed determining last route in Sinatra", e)
-          end
-
-          process_route_without_newrelic(*args, &block)
-        end
-
-        # If a transaction name is already set, this call will tromple over it.
-        # This is intentional, as typically passing to a separate route is like
-        # an entirely separate transaction, so we pick up the new name.
-        #
-        # If we're ignored, this remains safe, since set_transaction_name
-        # care for the gating on the transaction's existence for us.
-        def route_eval_with_newrelic(*args, &block)
-          begin
-            txn_name = TransactionNamer.transaction_name_for_route(env, request)
-            unless txn_name.nil?
-              ::NewRelic::Agent::Transaction.set_default_transaction_name(
-                "#{self.class.name}/#{txn_name}", :sinatra)
-            end
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed during route_eval to set transaction name", e)
-          end
-
-          route_eval_without_newrelic(*args, &block)
-        end
-
-        def dispatch_with_newrelic #THREAD_LOCAL_ACCESS
-          request_params = get_request_params
-          filtered_params = ParameterFiltering::apply_filters(request.env, request_params || {})
-
-          name = TransactionNamer.initial_transaction_name(request)
-          perform_action_with_newrelic_trace(:category => :sinatra,
-                                             :name => name,
-                                             :params => filtered_params) do
-            dispatch_and_notice_errors_with_newrelic
-          end
-        end
-
-        def get_request_params
-          begin
-            @request.params
-          rescue => e
-            NewRelic::Agent.logger.debug("Failed to get params from Rack request.", e)
-            nil
-          end
-        end
-
-        def dispatch_and_notice_errors_with_newrelic
-          dispatch_without_newrelic
-        ensure
-          # Will only see an error raised if :show_exceptions is true, but
-          # will always see them in the env hash if they occur
-          had_error = env.has_key?('sinatra.error')
-          ::NewRelic::Agent.notice_error(env['sinatra.error']) if had_error
-        end
-
-        def do_not_trace?
-          Ignorer.should_ignore?(self, :routes)
-        end
-
-        # Overrides ControllerInstrumentation implementation
-        def ignore_apdex?
-          Ignorer.should_ignore?(self, :apdex)
-        end
+  executes do
+    next unless Gem::Version.new(Sinatra::VERSION) < Gem::Version.new('2.0.0')
 
-        # Overrides ControllerInstrumentation implementation
-        def ignore_enduser?
-          Ignorer.should_ignore?(self, :enduser)
-        end
+    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. ' \
 
-      end
-    end
+    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) &&
+      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