newrelic_rpm 6.10.0.364 → 8.15.0

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

@@ -1,21 +1,13 @@
-# 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
 
 DependencyDetection.defer do
   named :excon
 
-  # We have two ways of instrumenting Excon:
-  # - For newer versions, use the middleware mechanism Excon exposes
-  # - For older versions, monkey-patch Excon::Connection#request
+  # We instrument Excon 0.19.0 and above using the middleware mechanism
   #
   # EXCON_MIN_VERSION is the minimum version we attempt to instrument at all.
-  # EXCON_MIDDLEWARE_MIN_VERSION is the min version we use the newer
-  #   instrumentation for.
-  #
-  # Note that middlewares were added to Excon prior to 0.19, but we don't
-  # use middleware-based instrumentation prior to that version because it didn't
-  # expose a way for middlewares to know about request failures.
   #
   # Why don't we use Excon.defaults[:instrumentor]?
   # While this might seem a perfect fit, it unfortunately isn't suitable in
@@ -25,48 +17,54 @@ DependencyDetection.defer do
   # so we could safely subscribe and not be clobbered by future subscribers,
   # but alas, it does not yet.
 
-  EXCON_MIN_VERSION = Gem::Version.new("0.10.1")
-  EXCON_MIDDLEWARE_MIN_VERSION = Gem::Version.new("0.19.0")
+  # TODO: MAJOR VERSION - update min version to 0.56.0
+  EXCON_MIN_VERSION = Gem::Version.new("0.19.0")
 
   depends_on do
-    defined?(::Excon) && defined?(::Excon::VERSION)
+    defined?(Excon) && defined?(Excon::VERSION)
   end
 
   executes do
-    excon_version = Gem::Version.new(::Excon::VERSION)
+    excon_version = Gem::Version.new(Excon::VERSION)
     if excon_version >= EXCON_MIN_VERSION
       install_excon_instrumentation(excon_version)
     else
-      ::NewRelic::Agent.logger.warn("Excon instrumentation requires at least version #{EXCON_MIN_VERSION}")
+      NewRelic::Agent.logger.warn("Excon instrumentation requires at least version #{EXCON_MIN_VERSION}")
     end
   end
 
+  executes do
+    next unless Gem::Version.new(Excon::VERSION) < Gem::Version.new('0.56.0')
+
+    deprecation_msg = 'Instrumentation for Excon versions below 0.56.0 is deprecated.' \
+      'They will stop being monitored in version 9.0.0. ' \
+      'Please upgrade your Excon version to continue receiving full support. '
+
+    NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_excon_version,
+      deprecation_msg
+    )
+
+    NewRelic::Agent.record_metric("Supportability/Deprecated/Excon", 1)
+  end
+
   def install_excon_instrumentation(excon_version)
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/excon_wrappers'
 
-    if excon_version >= EXCON_MIDDLEWARE_MIN_VERSION
-      install_middleware_excon_instrumentation
-    else
-      install_legacy_excon_instrumentation
-    end
+    install_middleware_excon_instrumentation
   end
 
   def install_middleware_excon_instrumentation
-    ::NewRelic::Agent.logger.info 'Installing middleware-based Excon instrumentation'
+    NewRelic::Agent.logger.info('Installing middleware-based Excon instrumentation')
     require 'new_relic/agent/instrumentation/excon/middleware'
     defaults = Excon.defaults
 
     if defaults[:middlewares]
-      defaults[:middlewares] << ::Excon::Middleware::NewRelicCrossAppTracing
+      defaults[:middlewares] << Excon::Middleware::NewRelicCrossAppTracing
     else
-      ::NewRelic::Agent.logger.warn("Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation")
+      NewRelic::Agent.logger.warn("Did not find :middlewares key in Excon.defaults, skipping Excon instrumentation")
     end
   end
-
-  def install_legacy_excon_instrumentation
-    ::NewRelic::Agent.logger.info 'Installing legacy Excon instrumentation'
-    require 'new_relic/agent/instrumentation/excon/connection'
-    ::Excon::Connection.install_newrelic_instrumentation
-  end
 end

data/lib/new_relic/agent/instrumentation/grape/chain.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
+
+module NewRelic::Agent::Instrumentation
+  module Grape
+    module Chain
+      def self.instrument!
+        Grape::Instrumentation.instrumented_class.class_eval do
+          def call_with_new_relic(env)
+            begin
+              call_without_new_relic(env)
+            ensure
+              Grape::Instrumentation.capture_transaction(env, self)
+            end
+          end
+
+          alias_method(:call_without_new_relic, :call)
+          alias_method(:call, :call_with_new_relic)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# 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/parameter_filtering'
+
+module NewRelic::Agent::Instrumentation
+  module Grape
+    module Instrumentation
+      extend self
+
+      # 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
+        defined?(::Grape::API::Instance) ? ::Grape::API::Instance : ::Grape::API
+      end
+
+      def capture_transaction(env, context)
+        begin
+          endpoint = env[API_ENDPOINT]
+          version = env[API_VERSION]
+
+          api_class = (context.class.respond_to?(:base) && context.class.base) || context.class
+          handle_transaction(endpoint, api_class.name, version)
+        rescue => e
+          ::NewRelic::Agent.logger.warn("Error in Grape instrumentation", e)
+        end
+      end
+
+      def prepare!
+        if defined?(::Grape::VERSION) && Gem::Version.new(::Grape::VERSION) >= Gem::Version.new("0.16.0")
+          send(:remove_method, :name_for_transaction_deprecated)
+        else
+          send(:remove_method, :name_for_transaction)
+          send(:alias_method, :name_for_transaction, :name_for_transaction_deprecated)
+        end
+      end
+
+      API_ENDPOINT = 'api.endpoint'.freeze
+      API_VERSION = 'api.version'.freeze
+      FORMAT_REGEX = /\(\/?\.[\:\w]*\)/.freeze # either :format (< 0.12.0) or .ext (>= 0.12.0)
+      VERSION_REGEX = /:version(\/|$)/.freeze
+      MIN_VERSION = Gem::Version.new("0.2.0")
+      PIPE_STRING = '|'.freeze
+
+      def handle_transaction(endpoint, class_name, version)
+        return unless endpoint && route = endpoint.route
+
+        name_transaction(route, class_name, version)
+        capture_params(endpoint)
+      end
+
+      def name_transaction(route, class_name, version)
+        txn_name = name_for_transaction(route, class_name, version)
+        segment_name = "Middleware/Grape/#{class_name}/call"
+        NewRelic::Agent::Transaction.set_default_transaction_name(txn_name, :grape)
+        txn = NewRelic::Agent::Transaction.tl_current
+        txn.segments.last.name = segment_name
+      end
+
+      def name_for_transaction(route, class_name, version)
+        action_name = route.path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
+        method_name = route.request_method
+        version ||= route.version
+
+        # defaulting does not set rack.env['api.version'] and route.version may return Array
+        #
+        version = version.join(PIPE_STRING) if Array === version
+
+        if version
+          action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
+          "#{class_name}-#{version}#{action_name} (#{method_name})"
+        else
+          "#{class_name}#{action_name} (#{method_name})"
+        end
+      end
+
+      def name_for_transaction_deprecated(route, class_name, version)
+        action_name = route.route_path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
+        method_name = route.route_method
+        version ||= route.route_version
+        if version
+          action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
+          "#{class_name}-#{version}#{action_name} (#{method_name})"
+        else
+          "#{class_name}#{action_name} (#{method_name})"
+        end
+      end
+
+      def capture_params(endpoint)
+        txn = ::NewRelic::Agent::Transaction.tl_current
+        env = endpoint.request.env
+        params = ::NewRelic::Agent::ParameterFiltering::apply_filters(env, endpoint.params)
+        params.delete("route_info")
+        txn.filtered_params = params
+        txn.merge_request_parameters(params)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# 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 Grape
+    module Prepend
+      def call(env)
+        begin
+          super(env)
+        ensure
+          Grape::Instrumentation.capture_transaction(env, self)
+        end
+      end
+    end
+  end
+end

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

@@ -1,145 +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
 
-require 'new_relic/agent/parameter_filtering'
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module GrapeInstrumentation
-        extend self
-
-        API_ENDPOINT   = 'api.endpoint'.freeze
-        API_VERSION    = 'api.version'.freeze
-        FORMAT_REGEX   = /\(\/?\.[\:\w]*\)/.freeze # either :format (< 0.12.0) or .ext (>= 0.12.0)
-        VERSION_REGEX  = /:version(\/|$)/.freeze
-        MIN_VERSION    = Gem::Version.new("0.2.0")
-        PIPE_STRING    = '|'.freeze
-
-        def handle_transaction(endpoint, class_name, version)
-          return unless endpoint && route = endpoint.route
-          name_transaction(route, class_name, version)
-          capture_params(endpoint)
-        end
-
-        def name_transaction(route, class_name, version)
-          txn_name = name_for_transaction(route, class_name, version)
-          segment_name = "Middleware/Grape/#{class_name}/call"
-          Transaction.set_default_transaction_name(txn_name, :grape)
-          txn = NewRelic::Agent::Transaction.tl_current
-          txn.segments.last.name = segment_name
-        end
-
-        def name_for_transaction(route, class_name, version)
-          action_name = route.path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
-          method_name = route.request_method
-          version ||= route.version
-
-          # defaulting does not set rack.env['api.version'] and route.version may return Array
-          #
-          version = version.join(PIPE_STRING) if Array === version
-
-          if version
-            action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
-            "#{class_name}-#{version}#{action_name} (#{method_name})"
-          else
-            "#{class_name}#{action_name} (#{method_name})"
-          end
-        end
-
-        def name_for_transaction_deprecated(route, class_name, version)
-          action_name = route.route_path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
-          method_name = route.route_method
-          version ||= route.route_version
-
-          if version
-            action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
-            "#{class_name}-#{version}#{action_name} (#{method_name})"
-          else
-            "#{class_name}#{action_name} (#{method_name})"
-          end
-        end
-
-        def capture_params(endpoint)
-          txn = Transaction.tl_current
-          env = endpoint.request.env
-          params = ParameterFiltering::apply_filters(env, endpoint.params)
-          params.delete("route_info")
-          txn.filtered_params = params
-          txn.merge_request_parameters(params)
-        end
-      end
-    end
-  end
-end
+require_relative 'grape/instrumentation'
+require_relative 'grape/chain'
+require_relative 'grape/prepend'
 
 DependencyDetection.defer do
   # Why not just :grape? newrelic-grape used that name already, and while we're
   # not shipping yet, overloading the name interferes with the plugin.
   named :grape_instrumentation
+  configure_with :grape
 
   depends_on do
-    ::NewRelic::Agent.config[:disable_grape] == false
-  end
-
-  depends_on do
-    defined?(::Grape::VERSION) &&
-      Gem::Version.new(::Grape::VERSION) >= ::NewRelic::Agent::Instrumentation::GrapeInstrumentation::MIN_VERSION
+    defined?(Grape::VERSION) &&
+      Gem::Version.new(Grape::VERSION) >= NewRelic::Agent::Instrumentation::Grape::Instrumentation::MIN_VERSION
   end
 
   depends_on do
     begin
       if defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?("newrelic-grape")
-        ::NewRelic::Agent.logger.info("Not installing New Relic supported Grape instrumentation because the third party newrelic-grape gem is present")
+        NewRelic::Agent.logger.info("Not installing New Relic supported Grape instrumentation because the third party newrelic-grape gem is present")
         false
       else
         true
       end
     rescue => e
-      ::NewRelic::Agent.logger.info("Could not determine if third party newrelic-grape gem is installed", e)
+      NewRelic::Agent.logger.info("Could not determine if third party newrelic-grape gem is installed", e)
       true
     end
   end
 
   executes do
-    NewRelic::Agent.logger.info 'Installing New Relic supported Grape instrumentation'
-    instrument_call
-  end
+    NewRelic::Agent::Instrumentation::Grape::Instrumentation.prepare!
 
-  def instrument_call
-    if defined?(Grape::VERSION) && Gem::Version.new(::Grape::VERSION) >= Gem::Version.new("0.16.0")
-      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :remove_method, :name_for_transaction_deprecated
+    if use_prepend?
+      instrumented_class = NewRelic::Agent::Instrumentation::Grape::Instrumentation.instrumented_class
+      prepend_instrument instrumented_class, NewRelic::Agent::Instrumentation::Grape::Prepend
     else
-      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :remove_method, :name_for_transaction
-      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :alias_method, :name_for_transaction, :name_for_transaction_deprecated
-    end
-
-    # 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
-    grape_api_class = defined?(Grape::API::Instance) ? ::Grape::API::Instance : ::Grape::API
-
-    grape_api_class.class_eval do
-      def call_with_new_relic(env)
-        begin
-          response = call_without_new_relic(env)
-        ensure
-          begin
-            endpoint = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_ENDPOINT]
-            version = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_VERSION]
-
-            api_class = (self.class.respond_to?(:base) && self.class.base) || self.class
-            ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, api_class.name, version)
-          rescue => e
-            ::NewRelic::Agent.logger.warn("Error in Grape instrumentation", e)
-          end
-        end
-
-        response
-      end
-
-      alias_method :call_without_new_relic, :call
-      alias_method :call, :call_with_new_relic
+      chain_instrument NewRelic::Agent::Instrumentation::Grape::Chain
     end
   end
 end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+require_relative 'instrumentation'
+
+module NewRelic::Agent::Instrumentation
+  module GRPC
+    module Client
+      module Chain
+        def self.instrument!
+          ::GRPC::ClientStub.class_eval do
+            include NewRelic::Agent::Instrumentation::GRPC::Client
+
+            def bidi_streamer_with_new_relic_trace(method, requests, marshal, unmarshal,
+              deadline: nil,
+              return_op: false,
+              parent: nil,
+              credentials: nil,
+              metadata: {},
+              &blk)
+
+              issue_request_with_tracing(:bidi_streamer, method, requests, marshal, unmarshal,
+                deadline: deadline,
+                return_op: return_op,
+                parent: parent,
+                credentials: credentials,
+                metadata: metadata)
+
+              # TODO: gRPC - confirm that &blk is being invoked correctly
+            end
+
+            alias bidi_streamer_without_newrelic_trace bidi_streamer
+            alias bidi_streamer bidi_streamer_with_newrelic_trace
+
+            def client_streamer_with_newrelic_trace(method, requests, marshal, unmarshal,
+              deadline: nil,
+              return_op: false,
+              parent: nil,
+              credentials: nil,
+              metadata: {})
+
+              issue_request_with_tracing(:client_streamer, method, requests, marshal, unmarshal,
+                deadline: deadline,
+                return_op: return_op,
+                parent: parent,
+                credentials: credentials,
+                metadata: metadata)
+            end
+
+            alias client_streamer_without_newrelic_trace client_streamer
+            alias client_streamer client_streamer_with_newrelic_trace
+
+            def request_response_with_newrelic_trace(method, req, marshal, unmarshal,
+              deadline: nil,
+              return_op: false,
+              parent: nil,
+              credentials: nil,
+              metadata: {})
+
+              issue_request_with_tracing(:request_response, method, req, marshal, unmarshal,
+                deadline: deadline,
+                return_op: return_op,
+                parent: parent,
+                credentials: credentials,
+                metadata: metadata)
+            end
+
+            alias request_response_without_newrelic_trace request_response
+            alias request_response request_response_with_newrelic_trace
+
+            def server_streamer_with_newrelic_trace(method, req, marshal, unmarshal,
+              deadline: nil,
+              return_op: false,
+              parent: nil,
+              credentials: nil,
+              metadata: {},
+              &blk)
+
+              issue_request_with_tracing(:server_streamer, method, req, marshal, unmarshal,
+                deadline: deadline,
+                return_op: return_op,
+                parent: parent,
+                credentials: credentials,
+                metadata: metadata)
+
+              # TODO: gRPC - confirm that &blk is being invoked correctly
+            end
+
+            alias server_streamer_without_newrelic_trace server_streamer
+            alias server_streamer server_streamer_with_newrelic_trace
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+require_relative 'request_wrapper'
+require_relative '../helper'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module GRPC
+        module Client
+          include NewRelic::Agent::Instrumentation::GRPC::Helper
+
+          def issue_request_with_tracing(grpc_type, method, requests, marshal, unmarshal,
+            deadline:, return_op:, parent:, credentials:, metadata:)
+            return yield unless trace_with_newrelic?
+
+            segment = request_segment(method)
+            request_wrapper = NewRelic::Agent::Instrumentation::GRPC::Client::RequestWrapper.new(@host)
+            segment.add_request_headers(request_wrapper)
+            metadata.merge!(request_wrapper.instance_variable_get(:@newrelic_metadata))
+            grpc_message = nil
+            grpc_status = 0
+
+            NewRelic::Agent.disable_all_tracing do
+              begin
+                yield
+              rescue => e
+                NewRelic::Agent.notice_error(e)
+                grpc_status, grpc_message = grpc_status_and_message_from_exception(e)
+                raise
+              end
+            end
+          ensure
+            add_attributes(segment, grpc_message: grpc_message, grpc_status: grpc_status, grpc_type: grpc_type)
+            ::NewRelic::Agent::Transaction::Segment.finish(segment)
+          end
+
+          private
+
+          def add_attributes(segment, attributes_hash)
+            return unless segment
+
+            attributes_hash.each do |attr, value|
+              segment.add_agent_attribute(attr, value)
+            end
+            segment.record_agent_attributes = true
+          end
+
+          def grpc_status_and_message_from_exception(exception)
+            return unless exception.message =~ /^(\d+):(\w+)\./
+
+            [Regexp.last_match(1).to_i, Regexp.last_match(2)]
+          end
+
+          def request_segment(method)
+            cleaned = cleaned_method(method)
+            NewRelic::Agent::Tracer.start_external_request_segment(
+              library: 'gRPC',
+              uri: method_uri(cleaned),
+              procedure: cleaned
+            )
+          end
+
+          def method_uri(method)
+            return unless @host && method
+
+            "grpc://#{@host}/#{method}"
+          end
+
+          def interceptor?
+            self.class.name.eql?('GRPC::InterceptorRegistry')
+          end
+
+          def trace_with_newrelic?
+            return @trace_with_newrelic unless @trace_with_newrelic.nil? # check for nil, not false
+
+            @trace_with_newrelic = if interceptor?
+              false
+            else
+              !host_denylisted?(@host)
+            end
+          end
+        end
+      end
+    end
+  end
+end