newrelic_rpm 6.15.0 → 7.2.0

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/middleware_proxy.rb

@@ -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)

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

@@ -34,7 +34,14 @@ DependencyDetection.defer do
     )
   end
 
+  # TODO: Remove in 8.0.0 release
   def install_mongo_instrumentation
+    ::NewRelic::Agent::Deprecator.deprecate "install_mongo_instrumentation", "install_mongo_command_subscriber", "8.0.0"
+    ::NewRelic::Agent.logger.warn("Installing deprecated Mongo instrumentation. " \
+        "This instrumentation will be removed in a future release. " \
+        "Update Mongo version to >= 2.1.0 for updated instrumentation"
+    )
+
     require 'new_relic/agent/datastores/mongo/metric_translator'
     require 'new_relic/agent/datastores/mongo/statement_formatter'
 

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

@@ -0,0 +1,44 @@
+# 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 'net_http/chain'
+require_relative 'net_http/prepend'
+
+DependencyDetection.defer do
+  named :net_http
+
+  depends_on do
+    defined?(Net) && defined?(Net::HTTP)
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Net:HTTP Wrappers'
+    require 'new_relic/agent/http_clients/net_http_wrappers'
+  end
+
+  # Airbrake uses method chaining on Net::HTTP in versions < 10.0.2 (10.0.2 updated to prepend for Net:HTTP)
+  conflicts_with_prepend do
+    defined?(::Airbrake) && defined?(::Airbrake::AIRBRAKE_VERSION) && ::Gem::Version.create(::Airbrake::AIRBRAKE_VERSION) < ::Gem::Version.create('10.0.2')
+  end
+
+  conflicts_with_prepend do
+    defined?(::ScoutApm)
+  end
+
+  conflicts_with_prepend do
+    defined?(::Rack::MiniProfiler)
+  end
+
+  conflicts_with_prepend do
+    source_location_for(Net::HTTP, "request") =~ /airbrake|profiler/i
+  end
+
+  executes do
+    if use_prepend?
+      prepend_instrument ::Net::HTTP, ::NewRelic::Agent::Instrumentation::NetHTTP::Prepend
+    else 
+      chain_instrument ::NewRelic::Agent::Instrumentation::NetHTTP::Chain
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/net_http/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.
+
+require_relative 'instrumentation'
+
+
+module NewRelic::Agent::Instrumentation
+  module NetHTTP
+    module Chain
+      def self.instrument!
+        Net::HTTP.class_eval do
+          include NewRelic::Agent::Instrumentation::NetHTTP
+
+          def request_with_newrelic_trace(request, *args, &block)
+            request_with_tracing(request) { request_without_newrelic_trace(request, *args, &block) }
+          end  
+    
+          alias request_without_newrelic_trace request
+          alias request request_with_newrelic_trace
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/{net_prepend.rb → net_http/instrumentation.rb}

@@ -5,8 +5,8 @@
 module NewRelic 
   module Agent 
     module Instrumentation
-      module NetPrepend
-        def request(request, *args, &block)
+      module NetHTTP
+        def request_with_tracing(request)
           wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
 
           segment = NewRelic::Agent::Tracer.start_external_request_segment(
@@ -23,7 +23,7 @@ module NewRelic
             # counting if connection wasn't started (which calls request again).
             NewRelic::Agent.disable_all_tracing do
               response = NewRelic::Agent::Tracer.capture_segment_error segment do
-                super
+                yield
               end
             end
   

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

@@ -0,0 +1,21 @@
+# 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 'instrumentation'
+
+module NewRelic 
+  module Agent 
+    module Instrumentation
+      module NetHTTP
+        module Prepend
+          include NewRelic::Agent::Instrumentation::NetHTTP
+          
+          def request(request, *args, &block)
+            request_with_tracing(request) { super }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,69 +2,34 @@
 # 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/instrumentation/sinatra'
+# Our Padrino instrumentation relies heavily on the fact that Padrino is
+# built on Sinatra. Although it wires up a lot of its own routing logic,
+# we only need to patch into Padrino's dispatch to get things started.
+#
+# Parts of the Sinatra instrumentation (such as the TransactionNamer) are
+# aware of Padrino as a potential target in areas where both Sinatra and
+# Padrino run through the same code.
+
+require_relative 'sinatra'
+require_relative 'padrino/chain'
+require_relative 'padrino/instrumentation'
+require_relative 'padrino/prepend'
 
 DependencyDetection.defer do
   @name = :padrino
+  configure_with :sinatra
 
-  depends_on do
-    !NewRelic::Agent.config[:disable_sinatra] &&
-      defined?(::Padrino) && defined?(::Padrino::Routing::InstanceMethods)
-  end
+  depends_on { defined?(::Padrino) && defined?(::Padrino::Routing::InstanceMethods) }
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Padrino instrumentation'
-
-    # Our Padrino instrumentation relies heavily on the fact that Padrino is
-    # built on Sinatra. Although it wires up a lot of its own routing logic,
-    # we only need to patch into Padrino's dispatch to get things started.
-    #
-    # Parts of the Sinatra instrumentation (such as the TransactionNamer) are
-    # aware of Padrino as a potential target in areas where both Sinatra and
-    # Padrino run through the same code.
-    module ::Padrino::Routing::InstanceMethods
-      include NewRelic::Agent::Instrumentation::Sinatra
-
-      alias dispatch_without_newrelic dispatch!
-      alias dispatch! dispatch_with_newrelic
-
-      # Padrino 0.13 mustermann routing
-      if private_method_defined?(:invoke_route)
-        include NewRelic::Agent::Instrumentation::Padrino
-
-        alias invoke_route_without_newrelic invoke_route
-        alias invoke_route invoke_route_with_newrelic
-      end
+    if use_prepend?
+      prepend_instrument ::Padrino::Routing::InstanceMethods, NewRelic::Agent::Instrumentation::Padrino::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Padrino::Chain
     end
   end
 end
 
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Padrino
 
-        def invoke_route_with_newrelic(*args, &block)
-          begin
-            env["newrelic.last_route"] = args[0].original_path
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed determining last route in Padrino", e)
-          end
 
-          begin
-            txn_name = ::NewRelic::Agent::Instrumentation::Sinatra::TransactionNamer.transaction_name_for_route(env, request)
-            unless txn_name.nil?
-              ::NewRelic::Agent::Transaction.set_default_transaction_name(
-                "#{self.class.name}/#{txn_name}", :sinatra)
-            end
-          rescue => e
-            ::NewRelic::Agent.logger.debug("Failed during invoke_route to set transaction name", e)
-          end
-
-          invoke_route_without_newrelic(*args, &block)
-        end
-
-      end
-    end
-  end
-end