newrelic_rpm 7.0.0 → 9.0.0

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

@@ -1,10 +1,10 @@
-# 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
 
 module NewRelic::Agent::Instrumentation
   module HTTPClient
-    module Chain 
+    module Chain
       def self.instrument!
         ::HTTPClient.class_eval do
           include NewRelic::Agent::Instrumentation::HTTPClient::Instrumentation
@@ -14,7 +14,7 @@ module NewRelic::Agent::Instrumentation
               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
@@ -22,4 +22,3 @@ module NewRelic::Agent::Instrumentation
     end
   end
 end
-

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

@@ -1,11 +1,11 @@
-# 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
 
 module NewRelic::Agent::Instrumentation
   module HTTPClient
     module Instrumentation
-      def with_tracing request, connection
+      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,
@@ -15,24 +15,23 @@ module NewRelic::Agent::Instrumentation
 
         begin
           response = nil
-          segment.add_request_headers wrapped_request
+          segment.add_request_headers(wrapped_request)
 
-          NewRelic::Agent::Tracer.capture_segment_error segment do
+          NewRelic::Agent::Tracer.capture_segment_error(segment) do
             yield
           end
 
           response = connection.pop
-          connection.push response
+          connection.push(response)
 
           wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPClientResponse.new(response)
-          segment.process_response_headers wrapped_response
+          segment.process_response_headers(wrapped_response)
 
           response
         ensure
-          segment.finish if segment
+          ::NewRelic::Agent::Transaction::Segment.finish(segment)
         end
       end
     end
   end
 end
-

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

@@ -1,7 +1,6 @@
-# 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
 
 module NewRelic::Agent::Instrumentation
   module HTTPClient
@@ -14,4 +13,3 @@ module NewRelic::Agent::Instrumentation
     end
   end
 end
-

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

@@ -1,6 +1,6 @@
-# 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_relative 'httpclient/instrumentation'
 require_relative 'httpclient/chain'
@@ -23,14 +23,14 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing HTTPClient instrumentation'
+    NewRelic::Agent.logger.info('Installing HTTPClient instrumentation')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/httpclient_wrappers'
   end
 
   executes do
     if use_prepend?
-      prepend_instrument ::HTTPClient, NewRelic::Agent::Instrumentation::HTTPClient::Prepend
+      prepend_instrument HTTPClient, NewRelic::Agent::Instrumentation::HTTPClient::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::HTTPClient::Chain
     end

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

@@ -1,6 +1,6 @@
-# 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
 
 module NewRelic::Agent::Instrumentation
   module HTTPrb
@@ -12,11 +12,11 @@ module NewRelic::Agent::Instrumentation
           def perform_with_newrelic_trace(request, options)
             with_tracing(request) { perform_without_newrelic_trace(request, options) }
           end
-       
+
           alias perform_without_newrelic_trace perform
           alias perform perform_with_newrelic_trace
         end
       end
     end
   end
-end
+end

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

@@ -1,30 +1,30 @@
-# 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
 
 module NewRelic::Agent::Instrumentation
   module HTTPrb
     def with_tracing(request)
       wrapped_request = ::NewRelic::Agent::HTTPClients::HTTPRequest.new(request)
-  
+
       begin
         segment = NewRelic::Agent::Tracer.start_external_request_segment(
           library: wrapped_request.type,
           uri: wrapped_request.uri,
           procedure: wrapped_request.method
         )
-  
-        segment.add_request_headers wrapped_request
-  
+
+        segment.add_request_headers(wrapped_request)
+
         response = NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
-  
-        wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPResponse.new response
-        segment.process_response_headers wrapped_response
-  
+
+        wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPResponse.new(response)
+        segment.process_response_headers(wrapped_response)
+
         response
       ensure
-        segment.finish if segment
+        ::NewRelic::Agent::Transaction::Segment.finish(segment)
       end
     end
   end
-end
+end