newrelic_rpm 8.2.0 → 9.0.0

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

@@ -1,4 +1,3 @@
-# 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
@@ -7,9 +6,10 @@ module NewRelic::Agent::Instrumentation
   module Memcache
     module Prepend
       extend Helper
+
       module_function
 
-      def client_prepender client_class
+      def client_prepender(client_class)
         Module.new do
           extend Helper
           include NewRelic::Agent::Instrumentation::Memcache::Tracer
@@ -23,28 +23,28 @@ module NewRelic::Agent::Instrumentation
       end
 
       def dalli_cas_prependers
-        yield ::Dalli::Client, dalli_client_prepender(dalli_cas_methods)
-        yield ::Dalli::Client, dalli_get_multi_prepender(:get_multi_cas)
+        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::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
+            yield(::Dalli::Protocol::Binary, dalli_server_prepender)
           else
-            yield ::Dalli::Server, dalli_server_prepender
+            yield(::Dalli::Server, dalli_server_prepender)
           end
 
-          yield ::Dalli::Ring, dalli_ring_prepender
+          yield(::Dalli::Ring, dalli_ring_prepender)
         else
-          yield ::Dalli::Client, dalli_client_prepender(client_methods)
+          yield(::Dalli::Client, dalli_client_prepender(client_methods))
         end
       end
 
-      def dalli_client_prepender supported_methods
+      def dalli_client_prepender(supported_methods)
         Module.new do
           extend Helper
           include NewRelic::Agent::Instrumentation::Memcache::Tracer
@@ -57,7 +57,7 @@ module NewRelic::Agent::Instrumentation
         end
       end
 
-      def dalli_get_multi_prepender method_name
+      def dalli_get_multi_prepender(method_name)
         Module.new do
           extend Helper
           include NewRelic::Agent::Instrumentation::Memcache::Tracer
@@ -73,7 +73,7 @@ module NewRelic::Agent::Instrumentation
           extend Helper
           include NewRelic::Agent::Instrumentation::Memcache::Tracer
 
-          def server_for_key key
+          def server_for_key(key)
             server_for_key_with_newrelic_tracing { super }
           end
         end
@@ -84,8 +84,15 @@ module NewRelic::Agent::Instrumentation
           extend Helper
           include NewRelic::Agent::Instrumentation::Memcache::Tracer
 
-          def send_multiget keys
-            send_multiget_with_newrelic_tracing(keys) { super }
+          # TODO: Dalli - 3.1.0 renamed send_multiget to pipelined_get, but the method is otherwise the same
+          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

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

@@ -1,10 +1,9 @@
-# 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.
+# 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)
@@ -19,14 +18,14 @@ require_relative 'memcache/prepend'
 DependencyDetection.defer do
   named :memcache_client
 
-  depends_on { defined? ::MemCache }
+  depends_on { defined? MemCache }
 
   executes do
     if use_prepend?
-      prepend_module = ::NewRelic::Agent::Instrumentation::Memcache::Prepend.client_prepender(::MemCache)
-      prepend_instrument ::MemCache, prepend_module, "MemcacheClient"
+      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"
+      chain_instrument_target MemCache, NewRelic::Agent::Instrumentation::Memcache::Chain, "MemcacheClient"
     end
   end
 end
@@ -34,32 +33,32 @@ end
 DependencyDetection.defer do
   named :memcached
 
-  depends_on { defined? ::Memcached }
+  depends_on { defined? Memcached }
 
   executes do
     if use_prepend?
-      prepend_module = ::NewRelic::Agent::Instrumentation::Memcache::Prepend.client_prepender(::Memcached)
-      prepend_instrument ::Memcached, prepend_module, "Memcached"
+      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"
+      chain_instrument_target Memcached, NewRelic::Agent::Instrumentation::Memcache::Chain, "Memcached"
     end
   end
 end
 
 DependencyDetection.defer do
-  named :dalli
+  @name = :dalli
   configure_with :memcache
 
-  depends_on { defined? ::Dalli::Client }
+  depends_on { defined? Dalli::Client }
 
   executes do
     if use_prepend?
-      prepend_module = ::NewRelic::Agent::Instrumentation::Memcache::Prepend
+      prepend_module = NewRelic::Agent::Instrumentation::Memcache::Prepend
       prepend_module.dalli_prependers do |client_class, instrumenting_module|
-        prepend_instrument client_class, instrumenting_module, "MemecacheDalli"
+        prepend_instrument client_class, instrumenting_module, "MemcachedDalli"
       end
     else
-      chain_instrument ::NewRelic::Agent::Instrumentation::Memcache::Dalli
+      chain_instrument NewRelic::Agent::Instrumentation::Memcache::Dalli
     end
   end
 end
@@ -68,21 +67,21 @@ end
 # 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
+  @name = :dalli_cas_client
   configure_with :memcache
 
-  depends_on { defined? ::Dalli::Client }
-  depends_on { ::NewRelic::Agent::Instrumentation::Memcache::DalliCAS.should_instrument? }
+  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.logger.info('Installing Dalli CAS Client Memcache instrumentation')
     if use_prepend?
-      prepend_module = ::NewRelic::Agent::Instrumentation::Memcache::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"
+        prepend_instrument client_class, instrumenting_module, "MemcachedDalliCAS"
       end
     else
-      chain_instrument ::NewRelic::Agent::Instrumentation::Memcache::DalliCAS
+      chain_instrument NewRelic::Agent::Instrumentation::Memcache::DalliCAS
     end
   end
 end

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

@@ -1,6 +1,6 @@
-# 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
 
 require 'new_relic/agent/method_tracer'
 require 'new_relic/agent/transaction'
@@ -15,7 +15,7 @@ module NewRelic
       class MiddlewareProxy
         include MiddlewareTracing
 
-        ANONYMOUS_CLASS   = "AnonymousClass".freeze
+        ANONYMOUS_CLASS = "AnonymousClass".freeze
         OBJECT_CLASS_NAME = "Object".freeze
 
         # This class is used to wrap classes that are passed to
@@ -50,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
@@ -60,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
@@ -86,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 = ANONYMOUS_CLASS if name.nil? || name == OBJECT_CLASS_NAME
           name
         end
 
@@ -104,7 +104,6 @@ module NewRelic
             @target.class
           end
         end
-
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# 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
@@ -27,10 +26,9 @@ module NewRelic
   module Agent
     module Instrumentation
       module MiddlewareTracing
-
         TXN_STARTED_KEY = 'newrelic.transaction_started'
-        CONTENT_TYPE    = 'Content-Type'
-        CONTENT_LENGTH  = 'Content-Length'
+        CONTENT_TYPE = 'Content-Type'
+        CONTENT_LENGTH = 'Content-Length'
 
         def _nr_has_middleware_tracing
           true
@@ -46,7 +44,7 @@ module NewRelic
           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) if defined? ::Rack
+          opts[:request] = ::Rack::Request.new(env.dup) if defined? ::Rack
           opts
         end
 
@@ -71,7 +69,7 @@ module NewRelic
           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)
+            length = length.reduce(0) { |sum, h| sum + h.to_i } if length.is_a?(Array)
             state.current_transaction.response_content_length = length
           end
         end
@@ -98,7 +96,7 @@ module NewRelic
 
             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)
 
             if first_middleware
               capture_response_attributes(state, result)

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

@@ -1,12 +1,12 @@
-# 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
 
 DependencyDetection.defer do
   named :mongo
 
   depends_on do
-    defined?(::Mongo)
+    defined?(Mongo)
   end
 
   depends_on do
@@ -18,7 +18,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    NewRelic::Agent.logger.info 'Installing Mongo instrumentation'
+    NewRelic::Agent.logger.info('Installing Mongo instrumentation')
     install_mongo_command_subscriber
   end
 

data/lib/new_relic/agent/instrumentation/mongodb_command_subscriber.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
+
 require 'new_relic/agent/datastores/mongo/event_formatter'
 
 module NewRelic
@@ -13,17 +14,18 @@ module NewRelic
         def started(event)
           begin
             return unless NewRelic::Agent::Tracer.tracing_enabled?
-            segments[event.operation_id] = start_segment event
+
+            segments[event.operation_id] = start_segment(event)
           rescue Exception => e
             log_notification_error('started', e)
           end
         end
 
-        ERROR_KEYS = %w{ writeErrors writeConcernError writeConcernErrors }.freeze
+        ERROR_KEYS = %w[ writeErrors writeConcernError writeConcernErrors ].freeze
 
         def error_key_present?(event)
           if reply = event.reply
-            ERROR_KEYS.detect{ |key| reply[key] }
+            ERROR_KEYS.detect { |key| reply[key] }
           end
         rescue
           false
@@ -32,20 +34,21 @@ module NewRelic
         def completed(event)
           begin
             return unless NewRelic::Agent::Tracer.tracing_enabled?
+
             segment = segments.delete(event.operation_id)
             return unless segment
 
-            # operations that succeed but have errors return CommandSucceeded 
-            # with an error_key that is populated with error specfics
+            # operations that succeed but have errors return CommandSucceeded
+            # with an error_key that is populated with error specifics
             if error_key = error_key_present?(event)
               # taking the last error as there can potentially be many
               attributes = event.reply[error_key][-1]
-              segment.notice_error Mongo::Error.new("%s (%s)" % [attributes["errmsg"], attributes["code"]])
+              segment.notice_error(Mongo::Error.new("%s (%s)" % [attributes["errmsg"], attributes["code"]]))
 
             # failing commands return a CommandFailed event with an error message
             # in the form of "% (%s)" for the message and code
-            elsif event.is_a? Mongo::Monitoring::Event::CommandFailed
-              segment.notice_error Mongo::Error.new(event.message)
+            elsif event.is_a?(Mongo::Monitoring::Event::CommandFailed)
+              segment.notice_error(Mongo::Error.new(event.message))
             end
             segment.finish
           rescue Exception => e
@@ -58,9 +61,9 @@ module NewRelic
 
         private
 
-        def start_segment event
-          host = host_from_address event.address
-          port_path_or_id = port_path_or_id_from_address event.address
+        def start_segment(event)
+          host = host_from_address(event.address)
+          port_path_or_id = port_path_or_id_from_address(event.address)
           segment = NewRelic::Agent::Tracer.start_datastore_segment(
             product: MONGODB,
             operation: operation(event.command_name),
@@ -76,7 +79,7 @@ module NewRelic
         def operation(command_name)
           # from 2.0 to 2.5, :findandmodify was the command_name
           if command_name == :findandmodify
-            :findAndModify 
+            :findAndModify
           else
             command_name
           end
@@ -107,31 +110,31 @@ module NewRelic
         LOCALHOST = "localhost".freeze
 
         def host_from_address(address)
-          if unix_domain_socket? address.host
+          if unix_domain_socket?(address.host)
             LOCALHOST
           else
             address.host
           end
         rescue => e
-          NewRelic::Agent.logger.debug "Failed to retrieve Mongo host: #{e}"
+          NewRelic::Agent.logger.debug("Failed to retrieve Mongo host: #{e}")
           UNKNOWN
         end
 
         def port_path_or_id_from_address(address)
-          if unix_domain_socket? address.host
+          if unix_domain_socket?(address.host)
             address.host
           else
             address.port
           end
         rescue => e
-          NewRelic::Agent.logger.debug "Failed to retrieve Mongo port_path_or_id: #{e}"
+          NewRelic::Agent.logger.debug("Failed to retrieve Mongo port_path_or_id: #{e}")
           UNKNOWN
         end
 
         SLASH = "/".freeze
 
         def unix_domain_socket?(host)
-          host.start_with? SLASH
+          host.start_with?(SLASH)
         end
       end
     end

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

@@ -1,10 +1,9 @@
-# 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
 
 require_relative 'instrumentation'
 
-
 module NewRelic::Agent::Instrumentation
   module NetHTTP
     module Chain
@@ -14,12 +13,12 @@ module NewRelic::Agent::Instrumentation
 
           def request_with_newrelic_trace(request, *args, &block)
             request_with_tracing(request) { request_without_newrelic_trace(request, *args, &block) }
-          end  
-    
+          end
+
           alias request_without_newrelic_trace request
           alias request request_with_newrelic_trace
         end
       end
     end
   end
-end
+end

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

@@ -1,9 +1,9 @@
-# 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 NewRelic
+  module Agent
     module Instrumentation
       module NetHTTP
         def request_with_tracing(request)
@@ -14,21 +14,21 @@ module NewRelic
             uri: wrapped_request.uri,
             procedure: wrapped_request.method
           )
-  
+
           begin
             response = nil
-            segment.add_request_headers wrapped_request
-  
+            segment.add_request_headers(wrapped_request)
+
             # RUBY-1244 Disable further tracing in request to avoid double
             # 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
+              response = NewRelic::Agent::Tracer.capture_segment_error(segment) do
                 yield
               end
             end
-  
-            wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
-            segment.process_response_headers wrapped_response
+
+            wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new(response)
+            segment.process_response_headers(wrapped_response)
             response
           ensure
             segment.finish

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

@@ -1,16 +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
 
 require_relative 'instrumentation'
 
-module NewRelic 
-  module Agent 
+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
@@ -18,4 +18,4 @@ module NewRelic
       end
     end
   end
-end
+end

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

@@ -1,6 +1,6 @@
-# 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
 
 require_relative 'net_http/chain'
 require_relative 'net_http/prepend'
@@ -13,21 +13,21 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Net:HTTP Wrappers'
+    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')
+    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)
+    defined?(ScoutApm)
   end
 
   conflicts_with_prepend do
-    defined?(::Rack::MiniProfiler)
+    defined?(Rack::MiniProfiler) && !defined?(Rack::MINI_PROFILER_PREPEND_NET_HTTP_PATCH)
   end
 
   conflicts_with_prepend do
@@ -36,9 +36,9 @@ DependencyDetection.defer do
 
   executes do
     if use_prepend?
-      prepend_instrument ::Net::HTTP, ::NewRelic::Agent::Instrumentation::NetHTTP::Prepend
-    else 
-      chain_instrument ::NewRelic::Agent::Instrumentation::NetHTTP::Chain
+      prepend_instrument Net::HTTP, NewRelic::Agent::Instrumentation::NetHTTP::Prepend
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::NetHTTP::Chain
     end
   end
 end