newrelic_rpm 5.5.0.348 → 7.2.0

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

@@ -1,162 +1,83 @@
 # 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
     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
-                  send_multiget_without_newrelic_trace(keys)
-                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
-                  __send__ method_name_without, *args, &block
-                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
+

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

@@ -0,0 +1,88 @@
+# 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 Tracer
+      SLASH = '/'
+      UNKNOWN = 'unknown'
+      LOCALHOST = 'localhost'
+      MULTIGET_METRIC_NAME = "get_multi_request"
+      MEMCACHED = "Memcached"
+
+      def with_newrelic_tracing operation, *args
+        segment = NewRelic::Agent::Tracer.start_datastore_segment \
+          product: MEMCACHED,
+          operation: operation
+
+        begin
+          NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+        ensure
+          if NewRelic::Agent.config[:capture_memcache_keys]
+            segment.notice_nosql_statement "#{operation} #{args.first.inspect}"
+          end
+          segment.finish if segment
+        end
+      end
+
+      def server_for_key_with_newrelic_tracing
+        yield.tap do |server|
+          begin
+            if txn = ::NewRelic::Agent::Tracer.current_transaction
+              segment = txn.current_segment
+              if ::NewRelic::Agent::Transaction::DatastoreSegment === segment
+                assign_instance_to(segment, server)
+              end
+            end
+          rescue => e
+            ::NewRelic::Agent.logger.warn "Unable to set instance info on datastore segment: #{e.message}"
+          end
+        end
+      end
+
+      def get_multi_with_newrelic_tracing method_name
+        segment = NewRelic::Agent::Tracer.start_segment \
+          name: "Ruby/Memcached/Dalli/#{method_name}"
+
+        begin
+          NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+        ensure
+          segment.finish if segment
+        end
+      end
+
+      def send_multiget_with_newrelic_tracing keys
+        segment = ::NewRelic::Agent::Tracer.start_datastore_segment \
+          product: MEMCACHED,
+          operation: MULTIGET_METRIC_NAME
+
+        begin
+          assign_instance_to(segment, self)
+          NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+        ensure
+          if ::NewRelic::Agent.config[:capture_memcache_keys]
+            segment.notice_nosql_statement "#{MULTIGET_METRIC_NAME} #{keys.inspect}"
+          end
+          segment.finish if segment
+        end
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# 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 Prepend
+      extend Helper
+      module_function
+
+      def client_prepender client_class
+        Module.new do
+          extend Helper
+          include NewRelic::Agent::Instrumentation::Memcache::Tracer
+
+          supported_methods_for(client_class, client_methods).each do |method_name|
+            define_method method_name do |*args, &block|
+              with_newrelic_tracing(method_name, *args) { super(*args, &block) }
+            end
+          end
+        end
+      end
+
+      def dalli_cas_prependers
+        yield ::Dalli::Client, dalli_client_prepender(dalli_cas_methods)
+        yield ::Dalli::Client, dalli_get_multi_prepender(:get_multi_cas)
+      end
+
+      def dalli_prependers
+        if supports_datastore_instances?
+          yield ::Dalli::Client, dalli_client_prepender(dalli_methods)
+          yield ::Dalli::Client, dalli_get_multi_prepender(:get_multi)
+          yield ::Dalli::Server, dalli_server_prepender
+          yield ::Dalli::Ring, dalli_ring_prepender
+        else
+          yield ::Dalli::Client, dalli_client_prepender(client_methods)
+        end
+      end
+
+      def dalli_client_prepender supported_methods
+        Module.new do
+          extend Helper
+          include NewRelic::Agent::Instrumentation::Memcache::Tracer
+
+          supported_methods.each do |method_name|
+            define_method method_name do |*args, &block|
+              with_newrelic_tracing(method_name, *args) { super(*args, &block) }
+            end
+          end
+        end
+      end
+
+      def dalli_get_multi_prepender method_name
+        Module.new do
+          extend Helper
+          include NewRelic::Agent::Instrumentation::Memcache::Tracer
+
+          define_method method_name do |*args, &block|
+            get_multi_with_newrelic_tracing(method_name) { super(*args, &block) }
+          end
+        end
+      end
+
+      def dalli_ring_prepender
+        Module.new do
+          extend Helper
+          include NewRelic::Agent::Instrumentation::Memcache::Tracer
+
+          def server_for_key key
+            server_for_key_with_newrelic_tracing { super }
+          end
+        end
+      end
+
+      def dalli_server_prepender
+        Module.new do
+          extend Helper
+          include NewRelic::Agent::Instrumentation::Memcache::Tracer
+
+          def send_multiget keys
+            send_multiget_with_newrelic_tracing(keys) { super }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/merb/controller.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.
 
 require 'set'
 

data/lib/new_relic/agent/instrumentation/merb/errors.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.
 
 DependencyDetection.defer do
   @name = :merb_error