newrelic_rpm 6.15.0 → 8.0.0

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

@@ -2,90 +2,19 @@
 # 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 'new_relic/agent/parameter_filtering'
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module GrapeInstrumentation
-        extend self
-
-        API_ENDPOINT   = 'api.endpoint'.freeze
-        API_VERSION    = 'api.version'.freeze
-        FORMAT_REGEX   = /\(\/?\.[\:\w]*\)/.freeze # either :format (< 0.12.0) or .ext (>= 0.12.0)
-        VERSION_REGEX  = /:version(\/|$)/.freeze
-        MIN_VERSION    = Gem::Version.new("0.2.0")
-        PIPE_STRING    = '|'.freeze
-
-        def handle_transaction(endpoint, class_name, version)
-          return unless endpoint && route = endpoint.route
-          name_transaction(route, class_name, version)
-          capture_params(endpoint)
-        end
-
-        def name_transaction(route, class_name, version)
-          txn_name = name_for_transaction(route, class_name, version)
-          segment_name = "Middleware/Grape/#{class_name}/call"
-          Transaction.set_default_transaction_name(txn_name, :grape)
-          txn = NewRelic::Agent::Transaction.tl_current
-          txn.segments.last.name = segment_name
-        end
-
-        def name_for_transaction(route, class_name, version)
-          action_name = route.path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
-          method_name = route.request_method
-          version ||= route.version
-
-          # defaulting does not set rack.env['api.version'] and route.version may return Array
-          #
-          version = version.join(PIPE_STRING) if Array === version
-
-          if version
-            action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
-            "#{class_name}-#{version}#{action_name} (#{method_name})"
-          else
-            "#{class_name}#{action_name} (#{method_name})"
-          end
-        end
-
-        def name_for_transaction_deprecated(route, class_name, version)
-          action_name = route.route_path.sub(FORMAT_REGEX, NewRelic::EMPTY_STR)
-          method_name = route.route_method
-          version ||= route.route_version
-
-          if version
-            action_name = action_name.sub(VERSION_REGEX, NewRelic::EMPTY_STR)
-            "#{class_name}-#{version}#{action_name} (#{method_name})"
-          else
-            "#{class_name}#{action_name} (#{method_name})"
-          end
-        end
-
-        def capture_params(endpoint)
-          txn = Transaction.tl_current
-          env = endpoint.request.env
-          params = ParameterFiltering::apply_filters(env, endpoint.params)
-          params.delete("route_info")
-          txn.filtered_params = params
-          txn.merge_request_parameters(params)
-        end
-      end
-    end
-  end
-end
+require_relative 'grape/instrumentation'
+require_relative 'grape/chain'
+require_relative 'grape/prepend'
 
 DependencyDetection.defer do
   # Why not just :grape? newrelic-grape used that name already, and while we're
   # not shipping yet, overloading the name interferes with the plugin.
   named :grape_instrumentation
-
-  depends_on do
-    ::NewRelic::Agent.config[:disable_grape] == false
-  end
-
+  configure_with :grape
+  
   depends_on do
     defined?(::Grape::VERSION) &&
-      Gem::Version.new(::Grape::VERSION) >= ::NewRelic::Agent::Instrumentation::GrapeInstrumentation::MIN_VERSION
+      Gem::Version.new(::Grape::VERSION) >= ::NewRelic::Agent::Instrumentation::Grape::Instrumentation::MIN_VERSION
   end
 
   depends_on do
@@ -103,43 +32,14 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info 'Installing New Relic supported Grape instrumentation'
-    instrument_call
-  end
+    ::NewRelic::Agent::Instrumentation::Grape::Instrumentation.prepare!
 
-  def instrument_call
-    if defined?(Grape::VERSION) && Gem::Version.new(::Grape::VERSION) >= Gem::Version.new("0.16.0")
-      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :remove_method, :name_for_transaction_deprecated
-    else
-      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :remove_method, :name_for_transaction
-      ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.send :alias_method, :name_for_transaction, :name_for_transaction_deprecated
-    end
-
-    # Since 1.2.0, the class `Grape::API` no longer refers to an API instance, rather, what used to be `Grape::API` is `Grape::API::Instance`
-    # https://github.com/ruby-grape/grape/blob/c20a73ac1e3f3ba1082005ed61bf69452373ba87/UPGRADING.md#upgrading-to--120
-    grape_api_class = defined?(Grape::API::Instance) ? ::Grape::API::Instance : ::Grape::API
-
-    grape_api_class.class_eval do
-      def call_with_new_relic(env)
-        begin
-          response = call_without_new_relic(env)
-        ensure
-          begin
-            endpoint = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_ENDPOINT]
-            version = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_VERSION]
-
-            api_class = (self.class.respond_to?(:base) && self.class.base) || self.class
-            ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, api_class.name, version)
-          rescue => e
-            ::NewRelic::Agent.logger.warn("Error in Grape instrumentation", e)
-          end
-        end
-
-        response
-      end
-
-      alias_method :call_without_new_relic, :call
-      alias_method :call, :call_with_new_relic
+    if use_prepend?
+      instrumented_class = ::NewRelic::Agent::Instrumentation::Grape::Instrumentation.instrumented_class
+      prepend_instrument instrumented_class, ::NewRelic::Agent::Instrumentation::Grape::Prepend
+    else 
+      chain_instrument ::NewRelic::Agent::Instrumentation::Grape::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/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/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/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/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

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

@@ -0,0 +1,56 @@
+# 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 Helper
+      DATASTORE_INSTANCES_SUPPORTED_VERSION = Gem::Version.new '2.6.4'
+
+      def supports_datastore_instances?
+        DATASTORE_INSTANCES_SUPPORTED_VERSION <= Gem::Version.new(::Dalli::VERSION)
+      end
+
+      def client_methods
+        [:get, :get_multi, :set, :add, :incr, :decr, :delete, :replace, :append,
+          :prepend, :cas, :single_get, :multi_get, :single_cas, :multi_cas]
+      end
+
+      def dalli_methods
+        [:get, :set, :add, :incr, :decr, :delete, :replace, :append, :prepend, :cas]
+      end
+
+      def dalli_cas_methods
+        [:get_cas, :set_cas, :replace_cas, :delete_cas]
+      end
+
+      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|
+          visibility = NewRelic::Helper.instance_method_visibility client_class, method_name
+          method_name_without = :"#{method_name}_without_newrelic_trace"
+
+          client_class.class_eval do
+            include NewRelic::Agent::Instrumentation::Memcache::Tracer
+
+            alias_method method_name_without, method_name
+
+            define_method method_name do |*args, &block|
+              with_newrelic_tracing(method_name, *args) { __send__ method_name_without, *args, &block }
+            end
+
+            __send__ visibility, method_name
+            __send__ visibility, method_name_without
+          end
+        end
+      end
+    end
+  end
+end
+