newrelic_rpm 5.7.0.350 → 9.0.0

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

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

@@ -0,0 +1,111 @@
+# 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
+  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 @@
+# 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.
+
+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

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

@@ -0,0 +1,69 @@
+# 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 Server
+      module Chain
+        def self.instrument!
+          # BEGIN RpcServer
+          ::GRPC::RpcServer.class_eval do
+            include NewRelic::Agent::Instrumentation::GRPC::Server
+
+            def add_http2_port_with_newrelic_trace(*args)
+              add_http2_port_with_tracing(*args) { add_http2_port_without_newrelic_trace(*args) }
+            end
+
+            alias add_http2_port_without_newrelic_trace add_http2_port
+            alias add_http2_port add_http2_port_with_newrelic_trace
+
+            def run_with_newrelic_trace(*args)
+              run_with_tracing(*args) { run_without_newrelic_trace(*args) }
+            end
+
+            alias run_without_newrelic_trace run
+            alias run run_with_newrelic_trace
+            # END RpcServer
+          end
+
+          # BEGIN RpcDesc
+          ::GRPC::RpcDesc.class_eval do
+            include NewRelic::Agent::Instrumentation::GRPC::Server
+
+            def handle_request_response_with_newrelic_trace(active_call, mth, inter_ctx)
+              handle_with_tracing(:request_response, active_call, mth, inter_ctx) { handle_request_response_without_newrelic_trace(active_call, mth, inter_ctx) }
+            end
+
+            alias handle_request_response_without_newrelic_trace handle_request_response
+            alias handle_request_response handle_request_response_with_newrelic_trace
+
+            def handle_client_streamer_with_newrelic_trace(active_call, mth, inter_ctx)
+              handle_with_tracing(:client_streamer, active_call, mth, inter_ctx) { handle_client_streamer_without_newrelic_trace(active_call, mth, inter_ctx) }
+            end
+
+            alias handle_client_streamer_without_newrelic_trace handle_client_streamer
+            alias handle_client_streamer handle_client_streamer_with_newrelic_trace
+
+            def handle_server_streamer_with_newrelic_trace(active_call, mth, inter_ctx)
+              handle_with_tracing(:server_streamer, active_call, mth, inter_ctx) { handle_server_streamer_without_newrelic_trace(active_call, mth, inter_ctx) }
+            end
+
+            alias handle_server_streamer_without_newrelic_trace handle_server_streamer
+            alias handle_server_streamer handle_server_streamer_with_newrelic_trace
+
+            def handle_bidi_streamer_with_newrelic_trace(active_call, mth, inter_ctx)
+              handle_with_tracing(:bidi_streamer, active_call, mth, inter_ctx) { handle_bidi_streamer_without_newrelic_trace(active_call, mth, inter_ctx) }
+            end
+
+            alias handle_bidi_streamer_without_newrelic_trace handle_bidi_streamer
+            alias handle_bidi_streamer handle_bidi_streamer_with_newrelic_trace
+            # END RpcDesc
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# 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 '../helper'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module GRPC
+        module Server
+          include NewRelic::Agent::Instrumentation::GRPC::Helper
+
+          DT_KEYS = [NewRelic::NEWRELIC_KEY, NewRelic::TRACEPARENT_KEY, NewRelic::TRACESTATE_KEY].freeze
+          INSTANCE_VAR_HOST = :@host_nr
+          INSTANCE_VAR_PORT = :@port_nr
+          INSTANCE_VAR_METHOD = :@method_nr
+          CATEGORY = :web
+          DESTINATIONS = AttributeFilter::DST_TRANSACTION_TRACER |
+            AttributeFilter::DST_TRANSACTION_EVENTS |
+            AttributeFilter::DST_ERROR_COLLECTOR
+
+          def handle_with_tracing(streamer_type, active_call, mth, _inter_ctx)
+            return yield unless trace_with_newrelic?
+
+            metadata = metadata_for_call(active_call)
+            txn = NewRelic::Agent::Transaction.start_new_transaction(NewRelic::Agent::Tracer.state,
+              CATEGORY,
+              trace_options)
+            add_attributes(txn, metadata, streamer_type)
+            process_distributed_tracing_headers(metadata)
+
+            begin
+              yield
+            rescue => e
+              NewRelic::Agent.notice_error(e)
+              raise
+            end
+          ensure
+            txn.finish if txn
+          end
+
+          def add_http2_port_with_tracing(*args)
+            set_host_and_port_on_server_instance(args.first)
+            yield
+          end
+
+          def run_with_tracing(*args)
+            set_host_and_port_and_method_info_on_desc
+            yield
+          end
+
+          private
+
+          def add_attributes(txn, metadata, streamer_type)
+            grpc_params(metadata, streamer_type).each do |attr, value|
+              txn.add_agent_attribute(attr, value, DESTINATIONS)
+              txn.current_segment.add_agent_attribute(attr, value) if txn.current_segment
+            end
+          end
+
+          def metadata_for_call(active_call)
+            return NewRelic::EMPTY_HASH unless active_call && active_call.metadata
+
+            active_call.metadata
+          end
+
+          def process_distributed_tracing_headers(metadata)
+            return unless metadata && !metadata.empty?
+
+            ::NewRelic::Agent::DistributedTracing::accept_distributed_trace_headers(metadata, 'Other')
+          end
+
+          def host_and_port_from_host_string(host_string)
+            return unless host_string
+
+            info = host_string.split(':').freeze
+            return unless info.size == 2
+
+            info
+          end
+
+          def set_host_and_port_on_server_instance(host_string)
+            info = host_and_port_from_host_string(host_string)
+            return unless info
+
+            instance_variable_set(INSTANCE_VAR_HOST, info.first)
+            instance_variable_set(INSTANCE_VAR_PORT, info.last)
+          end
+
+          def set_host_and_port_and_method_info_on_desc
+            rpc_descs.each do |method, desc|
+              desc.instance_variable_set(INSTANCE_VAR_HOST, instance_variable_get(INSTANCE_VAR_HOST))
+              desc.instance_variable_set(INSTANCE_VAR_PORT, instance_variable_get(INSTANCE_VAR_PORT))
+              desc.instance_variable_set(INSTANCE_VAR_METHOD, cleaned_method(method))
+            end
+          end
+
+          def grpc_headers(metadata)
+            metadata.reject { |k, v| DT_KEYS.include?(k) }
+          end
+
+          def grpc_params(metadata, streamer_type)
+            host = instance_variable_get(INSTANCE_VAR_HOST)
+            port = instance_variable_get(INSTANCE_VAR_PORT)
+            method = instance_variable_get(INSTANCE_VAR_METHOD)
+            {'request.headers': grpc_headers(metadata),
+             'request.uri': "grpc://#{host}:#{port}/#{method}",
+             'request.method': method,
+             'request.grpc_type': streamer_type}
+          end
+
+          def trace_options
+            method = instance_variable_get(INSTANCE_VAR_METHOD)
+            {category: CATEGORY, transaction_name: "Controller/#{method}"}
+          end
+
+          def trace_with_newrelic?
+            do_trace = instance_variable_get(:@trace_with_newrelic)
+            return do_trace unless do_trace.nil? # check for nil, not falsey
+
+            host = instance_variable_get(INSTANCE_VAR_HOST)
+            return true unless host
+
+            do_trace = !host_denylisted?(host)
+            instance_variable_set(:@trace_with_newrelic, do_trace)
+
+            do_trace
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/grpc/server/rpc_desc_prepend.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 'instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module GRPC
+        module Server
+          module RpcDescPrepend
+            include NewRelic::Agent::Instrumentation::GRPC::Server
+
+            def handle_request_response(active_call, mth, inter_ctx)
+              handle_with_tracing(:request_response, active_call, mth, inter_ctx) { super }
+            end
+
+            def handle_client_streamer(active_call, mth, inter_ctx)
+              handle_with_tracing(:client_streamer, active_call, mth, inter_ctx) { super }
+            end
+
+            def handle_server_streamer(active_call, mth, inter_ctx)
+              handle_with_tracing(:server_streamer, active_call, mth, inter_ctx) { super }
+            end
+
+            def handle_bidi_streamer(active_call, mth, inter_ctx)
+              handle_with_tracing(:bidi_streamer, active_call, mth, inter_ctx) { super }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/grpc/server/rpc_server_prepend.rb

@@ -0,0 +1,26 @@
+# 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 Server
+          module RpcServerPrepend
+            include NewRelic::Agent::Instrumentation::GRPC::Server
+            def add_http2_port(*args)
+              add_http2_port_with_tracing(*args) { super }
+            end
+
+            def run(*args)
+              run_with_tracing(*args) { super }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# 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 'grpc/client/chain'
+require_relative 'grpc/client/prepend'
+
+DependencyDetection.defer do
+  named :grpc_client
+
+  depends_on do
+    defined?(GRPC) && defined?(GRPC::ClientStub)
+  end
+
+  executes do
+    supportability_name = 'gRPC_Client'
+    if use_prepend?
+      prepend_instrument GRPC::ClientStub, NewRelic::Agent::Instrumentation::GRPC::Client::Prepend, supportability_name
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::GRPC::Client::Chain, supportability_name
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# 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 'grpc/server/chain'
+require_relative 'grpc/server/rpc_server_prepend'
+require_relative 'grpc/server/rpc_desc_prepend'
+
+DependencyDetection.defer do
+  named :grpc_server
+
+  depends_on do
+    defined?(GRPC) && defined?(GRPC::RpcServer) && defined?(GRPC::RpcDesc)
+  end
+
+  executes do
+    supportability_name = 'gRPC_Server'
+    if use_prepend?
+      prepend_instrument GRPC::RpcServer, NewRelic::Agent::Instrumentation::GRPC::Server::RpcServerPrepend, supportability_name
+      prepend_instrument GRPC::RpcDesc, NewRelic::Agent::Instrumentation::GRPC::Server::RpcDescPrepend, supportability_name
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::GRPC::Server::Chain, supportability_name
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/httpclient/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 HTTPClient
+    module Chain
+      def self.instrument!
+        ::HTTPClient.class_eval do
+          include NewRelic::Agent::Instrumentation::HTTPClient::Instrumentation
+
+          def do_get_block_with_newrelic(req, proxy, conn, &block)
+            with_tracing(req, conn) do
+              do_get_block_without_newrelic(req, proxy, conn, &block)
+            end
+          end
+
+          alias :do_get_block_without_newrelic :do_get_block
+          alias :do_get_block :do_get_block_with_newrelic
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# 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 HTTPClient
+    module Instrumentation
+      def with_tracing(request, connection)
+        wrapped_request = NewRelic::Agent::HTTPClients::HTTPClientRequest.new(request)
+        segment = NewRelic::Agent::Tracer.start_external_request_segment(
+          library: wrapped_request.type,
+          uri: wrapped_request.uri,
+          procedure: wrapped_request.method
+        )
+
+        begin
+          response = nil
+          segment.add_request_headers(wrapped_request)
+
+          NewRelic::Agent::Tracer.capture_segment_error(segment) do
+            yield
+          end
+
+          response = connection.pop
+          connection.push(response)
+
+          wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPClientResponse.new(response)
+          segment.process_response_headers(wrapped_response)
+
+          response
+        ensure
+          ::NewRelic::Agent::Transaction::Segment.finish(segment)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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 HTTPClient
+    module Prepend
+      include NewRelic::Agent::Instrumentation::HTTPClient::Instrumentation
+
+      def do_get_block(req, proxy, conn, &block)
+        with_tracing(req, conn) { super }
+      end
+    end
+  end
+end