newrelic_rpm 6.15.0 → 9.7.1

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

@@ -0,0 +1,104 @@
+# 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
+
+      INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
+
+      # Since 1.2.0, the class `Grape::API` no longer refers to an API instance, rather, what used to be `Grape::API` is `Grape::API::Instance`
+      # https://github.com/ruby-grape/grape/blob/c20a73ac1e3f3ba1082005ed61bf69452373ba87/UPGRADING.md#upgrading-to--120
+      def instrumented_class
+        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
+
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        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/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
-
-  depends_on do
-    ::NewRelic::Agent.config[:disable_grape] == false
-  end
+  @name = :grape_instrumentation
+  configure_with :grape
 
   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")
+      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')
         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 @@
+# 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 '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,94 @@
+# 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 'request_wrapper'
+require_relative '../helper'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module GRPC
+        module Client
+          include NewRelic::Agent::Instrumentation::GRPC::Helper
+
+          INSTRUMENTATION_NAME = 'gRPC_Client'
+
+          def issue_request_with_tracing(grpc_type, method, requests, marshal, unmarshal,
+            deadline:, return_op:, parent:, credentials:, metadata:)
+            return yield unless trace_with_newrelic?
+
+            NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+            segment = request_segment(method)
+            request_wrapper = NewRelic::Agent::Instrumentation::GRPC::Client::RequestWrapper.new(@host)
+            # do not insert CAT headers for gRPC requests https://github.com/newrelic/newrelic-ruby-agent/issues/1730
+            segment.add_request_headers(request_wrapper) unless CrossAppTracing.cross_app_enabled?
+            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

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

@@ -0,0 +1,111 @@
+# 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 'instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module GRPC
+        module Client
+          module Prepend
+            include NewRelic::Agent::Instrumentation::GRPC::Client
+
+            def bidi_streamer(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) do
+                  super(method, requests, marshal, unmarshal,
+                        deadline: deadline,
+                        return_op: return_op,
+                        parent: parent,
+                        credentials: credentials,
+                        metadata: metadata,
+                        &blk)
+                end
+            end
+
+            def client_streamer(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) do
+                  super(method, requests, marshal, unmarshal,
+                        deadline: deadline,
+                        return_op: return_op,
+                        parent: parent,
+                        credentials: credentials,
+                        metadata: metadata)
+                end
+            end
+
+            def request_response(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) do
+                  super(method, req, marshal, unmarshal,
+                        deadline: deadline,
+                        return_op: return_op,
+                        parent: parent,
+                        credentials: credentials,
+                        metadata: metadata)
+                end
+            end
+
+            def server_streamer(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) do
+                  super(method, req, marshal, unmarshal,
+                        deadline: deadline,
+                        return_op: return_op,
+                        parent: parent,
+                        credentials: credentials,
+                        metadata: metadata,
+                        &blk)
+                end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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
+      module GRPC
+        module Client
+          class RequestWrapper
+            attr_reader :newrelic_metadata
+
+            def initialize(host)
+              @host = host
+              @newrelic_metadata = {}
+            end
+
+            def host_from_header
+              @host
+            end
+
+            def []=(key, value)
+              @newrelic_metadata[key] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# 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
+      module GRPC
+        module Helper
+          NR_8T_HOST_PATTERN = %r{tracing\.(?:staging-)?edge\.nr-data}.freeze
+
+          def cleaned_method(method)
+            method = method.to_s unless method.is_a?(String)
+            return method unless method.start_with?('/')
+
+            method[1..-1]
+          end
+
+          def host_denylisted?(host)
+            return false unless host
+
+            ignore_patterns.any? { |regex| host.match?(regex) }
+          end
+
+          def ignore_patterns
+            ([NR_8T_HOST_PATTERN] + NewRelic::Agent.config[:'instrumentation.grpc.host_denylist']).freeze
+          end
+        end
+      end
+    end
+  end
+end