newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -0,0 +1,59 @@
+# 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')
+      BINARY_PROTOCOL_SUPPORTED_VERSION = Gem::Version.new('3.0.2')
+
+      def supports_datastore_instances?
+        DATASTORE_INSTANCES_SUPPORTED_VERSION <= Gem::Version.new(::Dalli::VERSION)
+      end
+
+      def supports_binary_protocol?
+        BINARY_PROTOCOL_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,99 @@
+# 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'
+      INSTRUMENTATION_NAME = 'Dalli'
+
+      def with_newrelic_tracing(operation, *args)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        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
+          ::NewRelic::Agent::Transaction::Segment.finish(segment)
+        end
+      end
+
+      def server_for_key_with_newrelic_tracing
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        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)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        segment = NewRelic::Agent::Tracer.start_segment(
+          name: "Ruby/Memcached/Dalli/#{method_name}"
+        )
+
+        begin
+          NewRelic::Agent::Tracer.capture_segment_error(segment) { yield }
+        ensure
+          ::NewRelic::Agent::Transaction::Segment.finish(segment)
+        end
+      end
+
+      def send_multiget_with_newrelic_tracing(keys)
+        NewRelic::Agent.record_instrumentation_invocation(INSTRUMENTATION_NAME)
+
+        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
+          ::NewRelic::Agent::Transaction::Segment.finish(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,103 @@
+# 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))
+
+          if supports_binary_protocol?
+            yield(::Dalli::Protocol::Binary, dalli_server_prepender)
+          else
+            yield(::Dalli::Server, dalli_server_prepender)
+          end
+
+          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
+
+          # TODO: MAJOR VERSION
+          # Dalli - 3.1.0 renamed send_multiget to pipelined_get, but the method is otherwise the same
+          # Once we no longer support Dalli < 3.1.0, remove this conditional logic
+          if Gem::Version.new(::Dalli::VERSION) >= Gem::Version.new('3.1.0')
+            def pipelined_get(keys)
+              send_multiget_with_newrelic_tracing(keys) { super }
+            end
+          else
+            def send_multiget(keys)
+              send_multiget_with_newrelic_tracing(keys) { super }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,143 +1,87 @@
-# 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
 
-# NOTE there are multiple implementations of the MemCache client in Ruby,
-# each with slightly different API's and semantics.
+# NOTE: there are multiple implementations of the Memcached client in Ruby,
+# each with slightly different APIs and semantics.
 # See:
-#     http://www.deveiate.org/code/Ruby-MemCache/ (Gem: Ruby-MemCache)
-#     http://seattlerb.rubyforge.org/memcache-client/ (Gem: memcache-client)
-#     http://github.com/mperham/dalli (Gem: dalli)
+#     https://rubygems.org/gems/Ruby-MemCache (Gem: Ruby-MemCache)
+#     https://github.com/mperham/memcache-client (Gem: memcache-client)
+#     https://github.com/mperham/dalli (Gem: dalli)
 
-require 'new_relic/agent/datastores/metric_helper'
-
-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|
-
-            visibility = NewRelic::Helper.instance_method_visibility client_class, method_name
-            method_name_without = :"#{method_name}_without_newrelic_trace"
-
-            client_class.class_eval do
-              alias_method method_name_without, method_name
-
-              define_method method_name do |*args, &block|
-                metrics = Datastores::MetricHelper.metrics_for("Memcached", method_name)
-
-                NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
-                  t0 = Time.now
-                  begin
-                    send method_name_without, *args, &block
-                  ensure
-                    if NewRelic::Agent.config[:capture_memcache_keys]
-                      NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil
-                    end
-                  end
-                end
-              end
-
-              send visibility, method_name
-              send visibility, method_name_without
-            end
-          end
-        end
-
-      end
-    end
-  end
-end
+require_relative 'memcache/helper'
+require_relative 'memcache/instrumentation'
+require_relative 'memcache/dalli'
+require_relative 'memcache/chain'
+require_relative 'memcache/prepend'
 
 DependencyDetection.defer do
   named :memcache_client
 
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
-
-  depends_on do
-    defined?(::MemCache)
-  end
+  depends_on { defined? MemCache }
 
   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.client_prepender(MemCache)
+      prepend_instrument MemCache, prepend_module, 'MemcacheClient'
+    else
+      chain_instrument_target MemCache, NewRelic::Agent::Instrumentation::Memcache::Chain, 'MemcacheClient'
+    end
   end
 end
 
 DependencyDetection.defer do
   named :memcached
 
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
-
-  depends_on do
-    defined?(::Memcached)
-  end
+  depends_on { defined? Memcached }
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Memcached instrumentation for memcached gem'
-    ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Memcached)
+    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 :dalli
-
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
+  @name = :dalli
+  configure_with :memcache
 
-  depends_on do
-    defined?(::Dalli::Client)
-  end
+  depends_on { defined? Dalli::Client }
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Memcache instrumentation for dalli gem'
-    ::NewRelic::Agent::Instrumentation::Memcache.instrument_methods(::Dalli::Client)
+    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, 'MemcachedDalli'
+      end
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Memcache::Dalli, 'MemcachedDalli'
+    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 :dalli_cas_client
-
-  depends_on do
-    NewRelic::Agent::Instrumentation::Memcache.enabled?
-  end
+  @name = :dalli_cas_client
+  configure_with :memcache
 
-  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, :get_multi_cas, :set_cas, :replace_cas,
-                        :delete_cas]
+  depends_on { defined? Dalli::Client }
+  depends_on { NewRelic::Agent::Instrumentation::Memcache::DalliCAS.should_instrument? }
 
   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.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, 'MemcachedDalliCAS'
+      end
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Memcache::DalliCAS, 'MemcachedDalliCAS'
+    end
   end
 end

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

@@ -1,10 +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 'new_relic/agent/method_tracer'
 require 'new_relic/agent/transaction'
-require 'new_relic/agent/transaction_state'
+require 'new_relic/agent/tracer'
 require 'new_relic/agent/instrumentation/queue_time'
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 require 'new_relic/agent/instrumentation/middleware_tracing'
@@ -15,8 +15,8 @@ module NewRelic
       class MiddlewareProxy
         include MiddlewareTracing
 
-        ANONYMOUS_CLASS   = "AnonymousClass".freeze unless defined?(ANONYMOUS_CLASS)
-        OBJECT_CLASS_NAME = "Object".freeze unless defined?(OBJECT_CLASS_NAME)
+        ANONYMOUS_CLASS = 'AnonymousClass'.freeze
+        OBJECT_CLASS_NAME = 'Object'.freeze
 
         # This class is used to wrap classes that are passed to
         # Rack::Builder#use without synchronously instantiating those classes.
@@ -31,6 +31,8 @@ module NewRelic
             middleware_instance = @middleware_class.new(*args, &blk)
             MiddlewareProxy.wrap(middleware_instance)
           end
+
+          ruby2_keywords(:new) if respond_to?(:ruby2_keywords, true)
         end
 
         def self.is_sinatra_app?(target)
@@ -48,7 +50,7 @@ module NewRelic
           )
         end
 
-        def self.wrap(target, is_app=false)
+        def self.wrap(target, is_app = false)
           if needs_wrapping?(target)
             self.new(target, is_app)
           else
@@ -58,13 +60,13 @@ module NewRelic
 
         attr_reader :target, :category, :transaction_options
 
-        def initialize(target, is_app=false)
-          @target            = target
-          @is_app            = is_app
-          @category          = determine_category
+        def initialize(target, is_app = false)
+          @target = target
+          @is_app = is_app
+          @category = determine_category
           @target_class_name = determine_class_name
-          @transaction_name  = "#{determine_prefix}#{@target_class_name}/call"
-          @transaction_options  = {
+          @transaction_name = "#{determine_prefix}#{@target_class_name}/call"
+          @transaction_options = {
             :transaction_name => @transaction_name
           }
         end
@@ -84,14 +86,14 @@ module NewRelic
         # In 'normal' usage, the target will be an application instance that
         # responds to #call. With Rails, however, the target may be a subclass
         # of Rails::Application that defines a method_missing that proxies #call
-        # to a singleton instance of the the subclass. We need to ensure that we
+        # to a singleton instance of the subclass. We need to ensure that we
         # capture the correct name in both cases.
         def determine_class_name
           clazz = class_for_target
 
           name = clazz.name
-          name = clazz.superclass.name if name.nil? || name == ""
-          name = ANONYMOUS_CLASS       if name.nil? || name == OBJECT_CLASS_NAME
+          name = clazz.superclass.name if name.nil? || name == ''
+          name = ANONYMOUS_CLASS if name.nil? || name == OBJECT_CLASS_NAME
           name
         end
 
@@ -102,7 +104,6 @@ module NewRelic
             @target.class
           end
         end
-
       end
     end
   end

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

@@ -1,10 +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 'new_relic/agent/method_tracer'
 require 'new_relic/agent/transaction'
-require 'new_relic/agent/transaction_state'
+require 'new_relic/agent/tracer'
 require 'new_relic/agent/instrumentation/queue_time'
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -26,7 +26,9 @@ module NewRelic
   module Agent
     module Instrumentation
       module MiddlewareTracing
-        TXN_STARTED_KEY = 'newrelic.transaction_started'.freeze unless defined?(TXN_STARTED_KEY)
+        TXN_STARTED_KEY = 'newrelic.transaction_started'
+        CONTENT_TYPE = 'Content-Type'
+        CONTENT_LENGTH = 'Content-Length'
 
         def _nr_has_middleware_tracing
           true
@@ -39,10 +41,11 @@ module NewRelic
         end
 
         def merge_first_middleware_options(opts, env)
-          opts.merge(
-            :request          => ::Rack::Request.new(env),
-            :apdex_start_time => QueueTime.parse_frontend_timestamp(env)
-          )
+          opts[:apdex_start_time] = QueueTime.parse_frontend_timestamp(env)
+          # this case is for the rare occasion that an app is using Puma::Rack
+          # without having ::Rack as a dependency
+          opts[:request] = ::Rack::Request.new(env.dup) if defined? ::Rack
+          opts
         end
 
         def note_transaction_started(env)
@@ -55,26 +58,57 @@ module NewRelic
           end
         end
 
+        def capture_response_content_type(state, result)
+          if result.is_a?(Array) && state.current_transaction
+            _, headers, _ = result
+            state.current_transaction.response_content_type = headers[CONTENT_TYPE]
+          end
+        end
+
+        def capture_response_content_length(state, result)
+          if result.is_a?(Array) && state.current_transaction
+            _, headers, _ = result
+            length = headers[CONTENT_LENGTH]
+            length = length.reduce(0) { |sum, h| sum + h.to_i } if length.is_a?(Array)
+            state.current_transaction.response_content_length = length
+          end
+        end
+
+        def capture_response_attributes(state, result)
+          capture_http_response_code(state, result)
+          capture_response_content_type(state, result)
+          capture_response_content_length(state, result)
+        end
+
         def call(env)
           first_middleware = note_transaction_started(env)
 
-          state = NewRelic::Agent::TransactionState.tl_get
+          state = NewRelic::Agent::Tracer.state
 
           begin
-            Transaction.start(state, category, build_transaction_options(env, first_middleware))
+            options = build_transaction_options(env, first_middleware)
+
+            finishable = Tracer.start_transaction_or_segment(
+              name: options[:transaction_name],
+              category: category,
+              options: options
+            )
+
             events.notify(:before_call, env) if first_middleware
 
-            result = (target == self) ? traced_call(env) : target.call(env)
+            result = target == self ? traced_call(env) : target.call(env)
 
-            capture_http_response_code(state, result)
-            events.notify(:after_call, env, result) if first_middleware
+            if first_middleware
+              capture_response_attributes(state, result)
+              events.notify(:after_call, env, result)
+            end
 
             result
           rescue Exception => e
             NewRelic::Agent.notice_error(e)
             raise e
           ensure
-            Transaction.stop(state)
+            finishable&.finish
           end
         end