newrelic_rpm 6.8.0.360 → 9.2.2

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 @@
+# 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 '../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
+          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)
+            end
+          end
+
+          def metadata_for_call(active_call)
+            return NewRelic::EMPTY_HASH unless 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 @@
+# 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 '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 @@
+# 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 '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

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

@@ -1,6 +1,10 @@
-# 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_relative 'httpclient/instrumentation'
+require_relative 'httpclient/chain'
+require_relative 'httpclient/prepend'
 
 DependencyDetection.defer do
   named :httpclient
@@ -19,40 +23,16 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing HTTPClient instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    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
-    class HTTPClient
-      def do_get_block_with_newrelic(req, proxy, conn, &block)
-        wrapped_request = NewRelic::Agent::HTTPClients::HTTPClientRequest.new(req)
-        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
-
-          do_get_block_without_newrelic(req, proxy, conn, &block)
-          response = conn.pop
-          conn.push response
-
-          wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPClientResponse.new(response)
-          segment.read_response_headers wrapped_response
-
-          response
-        ensure
-          segment.finish if segment
-        end
-      end
-
-      alias do_get_block_without_newrelic do_get_block
-      alias do_get_block do_get_block_with_newrelic
+    if use_prepend?
+      prepend_instrument HTTPClient, NewRelic::Agent::Instrumentation::HTTPClient::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::HTTPClient::Chain
     end
   end
 end

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

@@ -0,0 +1,22 @@
+# 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
+    module Chain
+      def self.instrument!
+        ::HTTP::Client.class_eval do
+          include NewRelic::Agent::Instrumentation::HTTPrb
+
+          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

data/lib/new_relic/agent/instrumentation/httprb/instrumentation.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::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)
+
+        response = NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+
+        wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPResponse.new(response)
+        segment.process_response_headers(wrapped_response)
+
+        response
+      ensure
+        ::NewRelic::Agent::Transaction::Segment.finish(segment)
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/httprb/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 HTTPrb
+    module Prepend
+      include NewRelic::Agent::Instrumentation::HTTPrb
+
+      def perform(request, options)
+        with_tracing(request) { super }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# 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 'httprb/instrumentation'
+require_relative 'httprb/chain'
+require_relative 'httprb/prepend'
+
+DependencyDetection.defer do
+  named :httprb
+
+  depends_on do
+    defined?(HTTP) && defined?(HTTP::Client)
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing http.rb Wrappers')
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
+    require 'new_relic/agent/http_clients/http_rb_wrappers'
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument HTTP::Client, NewRelic::Agent::Instrumentation::HTTPrb::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::HTTPrb::Chain
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -10,18 +10,18 @@ module NewRelic
           # We'll walk the superclass chain and see if
           # any class says 'yes, filter this one'.
 
-          while klass.respond_to? :newrelic_read_attr
+          while klass.respond_to?(:newrelic_read_attr)
             ignore_actions = klass.newrelic_read_attr(key)
 
             should_filter = case ignore_actions
             when Hash
-              only_actions   = Array(ignore_actions[:only])
+              only_actions = Array(ignore_actions[:only])
               except_actions = Array(ignore_actions[:except])
-              action_name    = action_name.to_sym
+              action_name = action_name.to_sym
 
               only_actions.include?(action_name) || (!except_actions.empty? && !except_actions.include?(action_name))
             else
-              !!ignore_actions
+              !ignore_actions.nil?
             end
 
             return true if should_filter
@@ -38,4 +38,3 @@ module NewRelic
     end
   end
 end
-

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

@@ -0,0 +1,21 @@
+# 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 Logger
+    def self.instrument!
+      ::Logger.class_eval do
+        include NewRelic::Agent::Instrumentation::Logger
+
+        alias_method(:format_message_without_new_relic, :format_message)
+
+        def format_message(severity, datetime, progname, msg)
+          format_message_with_tracing(severity, datetime, progname, msg) do
+            format_message_without_new_relic(severity, datetime, progname, msg)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# 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 Logger
+        def skip_instrumenting?
+          defined?(@skip_instrumenting) && @skip_instrumenting
+        end
+
+        # We support setting this on loggers which might not have
+        # instrumentation installed yet. This lets us disable in AgentLogger
+        # and AuditLogger without them having to know the inner details.
+        def self.mark_skip_instrumenting(logger)
+          return if logger.frozen?
+
+          logger.instance_variable_set(:@skip_instrumenting, true)
+        end
+
+        def self.clear_skip_instrumenting(logger)
+          return if logger.frozen?
+
+          logger.instance_variable_set(:@skip_instrumenting, false)
+        end
+
+        def mark_skip_instrumenting
+          return if frozen?
+
+          @skip_instrumenting = true
+        end
+
+        def clear_skip_instrumenting
+          return if frozen?
+
+          @skip_instrumenting = false
+        end
+
+        def self.enabled?
+          NewRelic::Agent.config[:'instrumentation.logger'] != 'disabled'
+        end
+
+        def format_message_with_tracing(severity, datetime, progname, msg)
+          formatted_message = yield
+          return formatted_message if skip_instrumenting?
+
+          begin
+            # It's critical we don't instrument logging from metric recording
+            # methods within NewRelic::Agent, or we'll stack overflow!!
+            mark_skip_instrumenting
+
+            unless ::NewRelic::Agent.agent.nil?
+              ::NewRelic::Agent.agent.log_event_aggregator.record(formatted_message, severity)
+              formatted_message = LocalLogDecorator.decorate(formatted_message)
+            end
+
+            formatted_message
+          ensure
+            clear_skip_instrumenting
+          end
+        end
+      end
+    end
+  end
+end