newrelic_rpm 6.13.1 → 7.2.0

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

@@ -2,6 +2,10 @@
 # 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 'httpclient/instrumentation'
+require_relative 'httpclient/chain'
+require_relative 'httpclient/prepend'
+
 DependencyDetection.defer do
   named :httpclient
 
@@ -25,36 +29,10 @@ DependencyDetection.defer do
   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
-
-          NewRelic::Agent::Tracer.capture_segment_error segment do
-            do_get_block_without_newrelic(req, proxy, conn, &block)
-          end
-          response = conn.pop
-          conn.push response
-
-          wrapped_response = ::NewRelic::Agent::HTTPClients::HTTPClientResponse.new(response)
-          segment.process_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/httpclient/chain.rb

@@ -0,0 +1,25 @@
+# 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.
+
+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,38 @@
+# 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.
+
+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
+          segment.finish if segment
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,17 @@
+# 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.
+
+
+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/httprb.rb

@@ -0,0 +1,29 @@
+# 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.
+
+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/httprb/chain.rb

@@ -0,0 +1,22 @@
+# 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.
+
+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 @@
+# 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.
+
+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
+        segment.finish if segment
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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.
+
+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/memcache.rb

@@ -1,6 +1,7 @@
 # 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
 
 # NOTE there are multiple implementations of the MemCache client in Ruby,
 # each with slightly different API's and semantics.
@@ -9,95 +10,79 @@
 #     http://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
 #     https://github.com/mperham/dalli (Gem: dalli)
 
-require 'new_relic/agent/datastores/metric_helper'
-require 'new_relic/agent/instrumentation/memcache/dalli'
+require_relative 'memcache/helper'
+require_relative 'memcache/instrumentation'
+require_relative 'memcache/dalli'
+require_relative 'memcache/chain'
+require_relative 'memcache/prepend'
 
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Memcache
-        module_function
-
-        def enabled?
-          !::NewRelic::Agent.config[:disable_memcache_instrumentation]
-        end
-
-        METHODS = [:get, :get_multi, :set, :add, :incr, :decr, :delete, :replace, :append,
-                   :prepend, :cas, :single_get, :multi_get, :single_cas, :multi_cas]
-
-        def supported_methods_for(client_class, methods)
-          methods.select do |method_name|
-            client_class.method_defined?(method_name) || client_class.private_method_defined?(method_name)
-          end
-        end
-
-        def instrument_methods(client_class, requested_methods = METHODS)
-          supported_methods_for(client_class, requested_methods).each do |method_name|
+DependencyDetection.defer do
+  named :memcache_client
 
-            visibility = NewRelic::Helper.instance_method_visibility client_class, method_name
-            method_name_without = :"#{method_name}_without_newrelic_trace"
+  depends_on { defined? ::MemCache }
 
-            client_class.class_eval do
-              alias_method method_name_without, method_name
+  executes do
+    if use_prepend?
+      prepend_module = ::NewRelic::Agent::Instrumentation::Memcache::Prepend.client_prepender(::MemCache)
+      prepend_instrument ::MemCache, prepend_module, "MemcacheClient"
+    else
+      chain_instrument_target ::MemCache, ::NewRelic::Agent::Instrumentation::Memcache::Chain, "MemcacheClient"
+    end
+  end
+end
 
-              define_method method_name do |*args, &block|
-                segment = NewRelic::Agent::Tracer.start_datastore_segment(
-                  product: "Memcached",
-                  operation: method_name
-                )
-                begin
-                  NewRelic::Agent::Tracer.capture_segment_error segment do
-                    send method_name_without, *args, &block
-                  end
-                ensure
-                  if NewRelic::Agent.config[:capture_memcache_keys]
-                    segment.notice_nosql_statement "#{method_name} #{args.first.inspect}"
-                  end
-                  segment.finish if segment
-                end
-              end
+DependencyDetection.defer do
+  named :memcached
 
-              send visibility, method_name
-              send visibility, method_name_without
-            end
-          end
-        end
+  depends_on { defined? ::Memcached }
 
-      end
+  executes do
+    if use_prepend?
+      prepend_module = ::NewRelic::Agent::Instrumentation::Memcache::Prepend.client_prepender(::Memcached)
+      prepend_instrument ::Memcached, prepend_module, "Memcached"
+    else
+      chain_instrument_target ::Memcached, ::NewRelic::Agent::Instrumentation::Memcache::Chain, "Memcached"
     end
   end
 end
 
 DependencyDetection.defer do
-  named :memcache_client
+  named :dalli
+  configure_with :memcache
 
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
-
-  depends_on do
-    defined?(::MemCache)
-  end
+  depends_on { defined? ::Dalli::Client }
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Memcached instrumentation for memcache-client gem'
-    NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::MemCache)
+    if use_prepend?
+      prepend_module = ::NewRelic::Agent::Instrumentation::Memcache::Prepend
+      prepend_module.dalli_prependers do |client_class, instrumenting_module|
+        prepend_instrument client_class, instrumenting_module, "MemecacheDalli"
+      end
+    else
+      chain_instrument ::NewRelic::Agent::Instrumentation::Memcache::Dalli
+    end
   end
 end
 
+# These CAS client methods are only optionally defined if users require
+# dalli/cas/client. Use a separate dependency block so it can potentially
+# re-evaluate after they've done that require.
 DependencyDetection.defer do
-  named :memcached
-
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
+  named :dalli_cas_client
+  configure_with :memcache
 
-  depends_on do
-    defined?(::Memcached)
-  end
+  depends_on { defined? ::Dalli::Client }
+  depends_on { ::NewRelic::Agent::Instrumentation::Memcache::DalliCAS.should_instrument? }
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Memcached instrumentation for memcached gem'
-    ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Memcached)
+    ::NewRelic::Agent.logger.info 'Installing Dalli CAS Client Memcache instrumentation'
+    if use_prepend?
+      prepend_module = ::NewRelic::Agent::Instrumentation::Memcache::Prepend
+      prepend_module.dalli_cas_prependers do |client_class, instrumenting_module|
+        prepend_instrument client_class, instrumenting_module, "MemecacheDalliCAS"
+      end
+    else
+      chain_instrument ::NewRelic::Agent::Instrumentation::Memcache::DalliCAS
+    end
   end
 end

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

@@ -0,0 +1,16 @@
+# 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 Memcache
+    module Chain
+      extend Helper
+
+      def self.instrument! target_class
+        instrument_methods target_class, client_methods
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/memcache/dalli.rb

@@ -1,166 +1,83 @@
 # 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
   module Agent
     module Instrumentation
       module Memcache
         module Dalli
-          extend self
+          extend Helper
+          module_function
 
-          MEMCACHED = "Memcached".freeze
-          METHODS = [:get, :set, :add, :incr, :decr, :delete, :replace, :append, :prepend, :cas]
-          SEND_MULTIGET_METRIC_NAME = "get_multi_request".freeze
-          DATASTORE_INSTANCES_SUPPORTED_VERSION = Gem::Version.new '2.6.4'
-          SLASH = '/'.freeze
-          UNKNOWN = 'unknown'.freeze
-          LOCALHOST = 'localhost'.freeze
-
-          def supports_datastore_instances?
-            DATASTORE_INSTANCES_SUPPORTED_VERSION <= Gem::Version.new(::Dalli::VERSION)
-          end
-
-          def instrument_methods
+          def instrument!
             if supports_datastore_instances?
-              ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client, METHODS)
+              instrument_methods(::Dalli::Client, dalli_methods)
               instrument_multi_method :get_multi
               instrument_send_multiget
               instrument_server_for_key
             else
-              ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client,
-                ::NewRelic::Agent::Instrumentation::Memcache::METHODS)
+              instrument_methods(::Dalli::Client, client_methods)
+            end
+          end
+
+          def instrument_multi_method method_name
+            visibility = NewRelic::Helper.instance_method_visibility ::Dalli::Client, method_name
+            method_name_without = :"#{method_name}_without_newrelic_trace"
+
+            ::Dalli::Client.class_eval do
+              alias_method method_name_without, method_name
+
+              define_method method_name do |*args, &block|
+                get_multi_with_newrelic_tracing(method_name) { __send__ method_name_without, *args, &block }
+              end
+
+              __send__ visibility, method_name
+              __send__ visibility, method_name_without
             end
           end
 
           def instrument_server_for_key
             ::Dalli::Ring.class_eval do
+              include NewRelic::Agent::Instrumentation::Memcache::Tracer
+
               alias_method :server_for_key_without_newrelic_trace, :server_for_key
 
               def server_for_key key
-                server = server_for_key_without_newrelic_trace key
-                begin
-                  if txn = ::NewRelic::Agent::Tracer.current_transaction
-                    segment = txn.current_segment
-                    if ::NewRelic::Agent::Transaction::DatastoreSegment === segment
-                      ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
-                    end
-                  end
-                rescue => e
-                  ::NewRelic::Agent.logger.warn "Unable to set instance info on datastore segment: #{e.message}"
-                end
-                server
+                server_for_key_with_newrelic_tracing { server_for_key_without_newrelic_trace key }
               end
             end
           end
 
           def instrument_send_multiget
             ::Dalli::Server.class_eval do
+              include NewRelic::Agent::Instrumentation::Memcache::Tracer
               alias_method :send_multiget_without_newrelic_trace, :send_multiget
 
-              def send_multiget(keys)
-                segment = ::NewRelic::Agent::Tracer.start_datastore_segment(
-                  product: MEMCACHED,
-                  operation: SEND_MULTIGET_METRIC_NAME
-                )
-                ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, self)
-
-                begin
-                  NewRelic::Agent::Tracer.capture_segment_error segment do                  
-                    send_multiget_without_newrelic_trace(keys)
-                  end
-                ensure
-                  if ::NewRelic::Agent.config[:capture_memcache_keys]
-                    segment.notice_nosql_statement "#{SEND_MULTIGET_METRIC_NAME} #{keys.inspect}"
-                  end
-                  segment.finish if segment
-                end
+              def send_multiget keys
+                send_multiget_with_newrelic_tracing(keys) { send_multiget_without_newrelic_trace keys }
               end
             end
           end
+        end
 
-          def instrument_multi_method method_name
-            visibility = NewRelic::Helper.instance_method_visibility ::Dalli::Client, method_name
-            method_name_without = :"#{method_name}_without_newrelic_trace"
-
-            ::Dalli::Client.class_eval do
-              alias_method method_name_without, method_name
-
-              define_method method_name do |*args, &block|
-                segment = NewRelic::Agent::Tracer.start_segment name: "Ruby/Memcached/Dalli/#{method_name}"
-                begin
-                  NewRelic::Agent::Tracer.capture_segment_error segment do                  
-                    __send__ method_name_without, *args, &block
-                  end
-                ensure
-                  segment.finish if segment
-                end
-              end
+        module DalliCAS
+          extend Dalli
+          extend Helper
+          module_function
 
-              __send__ visibility, method_name
-              __send__ visibility, method_name_without
-            end
+          def should_instrument?
+            supported_methods_for(::Dalli::Client, dalli_cas_methods).any?
           end
 
-          def assign_instance_to segment, server
-            host = port_path_or_id = nil
-            if server.hostname.start_with? SLASH
-              host = LOCALHOST
-              port_path_or_id = server.hostname
-            else
-              host = server.hostname
-              port_path_or_id = server.port
-            end
-            segment.set_instance_info host, port_path_or_id
-          rescue => e
-            ::NewRelic::Agent.logger.debug "Failed to retrieve memcached instance info: #{e.message}"
-            segment.set_instance_info UNKNOWN, UNKNOWN
+          def instrument!
+            instrument_methods ::Dalli::Client, dalli_cas_methods
+            instrument_multi_method :get_multi_cas
           end
-
         end
       end
     end
   end
 end
 
-DependencyDetection.defer do
-  named :dalli
-
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
-
-  depends_on do
-    defined?(::Dalli::Client)
-  end
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Memcache instrumentation for dalli gem'
-    ::NewRelic::Agent::Instrumentation::Memcache::Dalli.instrument_methods
-  end
-end
-
-DependencyDetection.defer do
-  named :dalli_cas_client
-
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
-
-  depends_on do
-    # These CAS client methods are only optionally defined if users require
-    # dalli/cas/client. Use a separate dependency block so it can potentially
-    # re-evaluate after they've done that require.
-    defined?(::Dalli::Client) &&
-      ::NewRelic::Agent::Instrumentation::Memcache.supported_methods_for(::Dalli::Client,
-                                                                         CAS_CLIENT_METHODS).any?
-  end
-
-  CAS_CLIENT_METHODS = [:get_cas, :set_cas, :replace_cas, :delete_cas]
-
-  executes do
-    ::NewRelic::Agent.logger.info 'Installing Dalli CAS Client Memcache instrumentation'
-    ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client, CAS_CLIENT_METHODS)
-    ::NewRelic::Agent::Instrumentation::Memcache::Dalli.instrument_multi_method(:get_multi_cas)
-  end
-end